leetcode:LRU Cache

COPY FROM:http://www.cnblogs.com/x1957/p/3485053.html

做个LRU，算法挺简单的。。。

而且好像用处也挺广的（？），用的比较广的一个cache算法

比如我cache只有4这么大，现在有很多元素1,2,2,4,2,5,3

cache                  income:1

1

cache                  income:2

2 1

cache                  income:1

1 2

cache                  income:4

4 1 2

cache                  income:2

2 4 1

cache                  income:5

5 2 4 1

cache                  income:3

3 5 2 4

大概就这么个样子。。。

看出来了吧，新按元素使用率（？）排序，最后使用的放最前面

如果cache不满，新来的放第一个，如果满了，在cache里面就把里面那个放到第一个，如果不在就删除最后一个，然后把新元素放第一个。

ok，算法就说完了。。

talk is cheap , show me the code...

经常看到各种经典算法，感觉都很简单啊。。。

当然这个确实也简单

就是用一个双向链表+map

不用map查找的话就要遍历了。。。时间复杂度就上升了

双向链表的好处就是。。。用map定位到那个节点，然后很方便的移动或者删除啊什么的，单向就做不到啦，因为你要删除还要找prev

双向链表就不写了，用stl的list代替

struct CacheNode{
    int key;
    int value;
    CacheNode(int k , int v) : key(k) , value(v){}
};
class LRUCache{
public:
    LRUCache(int capacity) {
        size = capacity;
    }
    
    int get(int key) {
        if(cacheMap.find(key) != cacheMap.end()){
           auto it = cacheMap[key];
           cacheList.splice(cacheList.begin() , cacheList , it);
           cacheMap[key] = cacheList.begin();
           return cacheList.begin()->value;
        }else{
            return -1;
        }
    }
    
    void set(int key, int value) {
        if (cacheMap.find(key) == cacheMap.end()){
            if(cacheList.size() == size){
                cacheMap.erase(cacheList.back().key);
                cacheList.pop_back();
            }
            cacheList.push_front(CacheNode(key , value));
            cacheMap[key] = cacheList.begin();
        }else{
           auto it = cacheMap[key];
           cacheList.splice(cacheList.begin() , cacheList , it);
           cacheMap[key] = cacheList.begin();
           cacheList.begin()->value = value;
        }
    }
private:
    int size;
    list<CacheNode> cacheList;
    unordered_map<int , list<CacheNode>::iterator > cacheMap;
};