146. LRU Cache

Posted 2020-11-23 lychnis

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and put.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
put(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

The cache is initialized with a positive capacity.

Follow up:
Could you do both operations in O(1) time complexity?

Example:

LRUCache cache = new LRUCache( 2 /* capacity */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // returns 1
cache.put(3, 3);    // evicts key 2
cache.get(2);       // returns -1 (not found)
cache.put(4, 4);    // evicts key 1
cache.get(1);       // returns -1 (not found)
cache.get(3);       // returns 3
cache.get(4);       // returns 4

 

Accepted

384,140

Submissions

1,352,856

 

 

最初的想法可能是用map来做排序时间. 但是实际上followup要求O1时间复杂度, 把map换成list就可以了.

注意 list 插入的时候选择头部插入, 而不是尾部插入. 因为尾部插入以后好像没办法获取迭代器, 如果强硬用insert来实现, 则好像要慢一点. 大概10ms的样子.

 

class LRUCache {
    unordered_map<uint32_t,pair<list<uint32_t>::iterator,uint32_t>> cache;
    list<uint32_t> order;
    int capacity;
    
public:
    LRUCache(int capacity) {
        this->capacity = capacity;    
    }
    
    int get(int key) {
        auto iter=cache.find(key);
        if(iter==cache.end())return -1;
        update(iter);
        return iter->second.second;
    }
    
    void update(unordered_map<uint32_t,pair<list<uint32_t>::iterator,uint32_t>>::iterator i)
    {
        order.erase(i->second.first);
        order.push_front(i->first);
        i->second.first=order.begin();
    }
    
    void put(int key, int value) {
        auto iter=cache.find(key);
        if(iter==cache.end())
        {
            if(cache.size()>=capacity)
            {
                cache.erase(order.back());
                order.pop_back();
            }
            order.push_front(key);
            cache.insert(make_pair(key,make_pair(order.begin(),value)));
        }
        else
        {
            iter->second.second=value;
            update(iter);
        }
    }
};