LRU Cache

题目：

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.

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

代码：

class LRUCache {
public:
    LRUCache(int capacity) : _capacity(capacity) {}

    int get(int key) 
    {
        auto it = cache.find(key);
        if (it == cache.end()) 
            return -1;
        touch(it);
        return it->second.first;
    }

    void set(int key, int value) {
        auto it = cache.find(key);
        if (it != cache.end()) 
            touch(it);
        else {
            if (cache.size() == _capacity) 
            {
                cache.erase(used.back());
                used.pop_back();
            }
            used.push_front(key);
        }
        cache[key] = { value, used.begin() };
    }

private:
    typedef list<int> LI;
    typedef pair<int, LI::iterator> PII;
    typedef unordered_map<int, PII> HIPII;

    void touch(HIPII::iterator it) {
        int key = it->first;
        used.erase(it->second.second);
        used.push_front(key);
        it->second.second = used.begin();
    }

    HIPII cache;
    LI used;
    int _capacity;
};

代码简化：

class LRUCache {
public:
    LRUCache(int capacity) : _capacity(capacity) {

    }

    int get(int key) {
        auto it = cache.find(key);
        if (it == cache.end())
            return -1;
        else
        {
            nodeList.erase(it->second);
            KVPair Pair(key, it->second->v);
            nodeList.push_front(Pair);
            cache[key] = nodeList.begin();
            return it->second->v;
        }
    }

    void put(int key, int value) {
        if (get(key) != -1)
        {
            cache[key]->v = value;
            return;
        }
        KVPair Pair(key, value);
        nodeList.push_front(Pair);
        if (cache.size() == _capacity)
        {
            cache.erase(nodeList.back().k);
            nodeList.pop_back();
        }
        cache[key] = nodeList.begin();
    }
private:
    struct KVPair
    {
        int k;
        int v;
        KVPair(int x, int y) : k(x), v(y) {}
    };
    list<KVPair> nodeList;
    unordered_map<int, list<KVPair>::iterator> cache;
    int _capacity;
};