LRU Cache

题目描述：设计一个数据结构用来实现最近最少使用的缓存，它支持get 和set方法：

get(key) -- 如果key在缓存中，返回key所对应的value值(通常为正数)，否则返回-1；

set(key，value) -- 如果key不在缓存中，将其插入缓存，如果缓存已经到达容量上限，则将最近最少使用的项退出缓存，再将其插入。

分析：我们可以采用一个双向链表来保存数据，表头表示最近使用过的数据，而表尾表示最近最少使用的数据。当用set插入数据时，先在其中查找是否存在，如果存在则将其移动到表头后面；如果不存在则将其插入到表头后面，并且将表尾前面的元素删除。当用get返回数据时，查看是否存在，如果存在，先将其移动到表头，再返回该值，不存在则返回null. 具体代码如下：

class LRUCache{
public:
    LRUCache(int capacity) 
    {
        if(capacity < 1) return;
        head = new link(0, 0);  
        tail = new link(0, 0);  
        head->next = tail;  
        tail->pre = head;  
        mp.clear();  
        size = 0;
        cap = capacity;
    }
    
    int get(int key) 
    {
        map<int, link*>::iterator it = mp.find(key);  
        if (it != mp.end()) {  
            link* cur = (*it).second;  
            moveToHead(cur); 
            return cur->value;  
        } else  
            return -1;  
    }
    
    void set(int key, int value) 
    {
        if (cap < 1)  return;  
        map<int, link*>::iterator it = mp.find(key);  
        if (it != mp.end()) 
        {  
            link* cur = (*it).second;  
            cur->value = value;
            moveToHead(cur);  
        } 
        else
        {  
            link* tmp = new link(key,value);  
            insertHead(tmp);  
            mp[key] = tmp;  
            if (size < cap) 
            {  
                size++;  
            } 
            else 
            {  
                link* deltmp = tail->pre;  
                tail->pre = deltmp->pre;  
                deltmp->pre->next = tail;  
                it = mp.find(deltmp->key);  
                mp.erase(it);  
                delete deltmp;  
            }  
        }  
    }
    void moveToHead(link* cur)
    {
       cur->pre->next = cur->next;
       cur->next->pre = cur->pre;
       insertHead(cur);
    }
    void insertHead(link* cur)
    {
        cur->next = head->next;
        head->next->pre = cur;
        cur->pre = head;
        head->next = cur;
    }
private:
    map<int,link*> mp;
    int size;
    int cap;
    link* head;
    link* tail;
};
struct link
    {
        link* pre;
        link* next;
        int key;
        int value;
        link(int key,int value):key(key),value(value),
        pre(NULL),next(NULL)
        {};
    };

上述函数主要用到容器map的find函数实现通过key来找到对应value的功能，其余的就是双链表的插入与删除操作，都是基本的数据结构知识。