LRU缓存策略

问题描述：

为最近最少使用（LRU）缓存策略设计一个数据结构，它应该支持以下操作：获取数据（get）和写入数据（set）。

获取数据get(key)：如果缓存中存在key，则获取其数据值（通常是正数），否则返回-1。

写入数据set(key, value)：如果key还没有在缓存中，则写入其数据值。当缓存达到上限，它应该在写入新数据之前删除最近最少使用的数据用来腾出空闲位置。

分析：

使用hashmap加双向链表，hashmap的key是原始数据key，value是存储原始数据key和value的自定义结构体Node。

Node存储原始数据的key、value，以及指向上一个节点和下一个节点的指针pre和next。

私有方法remove是将一个节点从双向链表中移除出来；insert是将一个节点插入到头结点处。

那么每次获取数据get（key）后，调用remove方法，再调用insert方法。

写入数据时，调用insert方法；若大小超过capacity，则释放尾节点，并从hashmap里移除该节点对应的key，value。

struct Node  
{  
    Node(int _key,int _value){key = _key;value = _value;pre = next = NULL;}  
    int key;  
    int value;  
    Node*pre;  
    Node*next;  
};  
class LRUCache{  
public:  
    // @param capacity, an integer  
    LRUCache(int capacity) {  
        // write your code here  
        this->capacity = capacity;  
        size = 0;  
        head = NULL;  
        tail = NULL;  
    }  
      
    // @return an integer  
    int get(int key) {  
        // write your code here  
        if(m.find(key)==m.end())  
        {  
            return -1;  
        }  
        else  
        {  
            Node* n = m[key];  
            int ret = n->value;  
            if(head!=n)  
            {  
                remove(n);
                insert(n);
            }  
            return ret;  
        }  
    }  
  
    // @param key, an integer  
    // @param value, an integer  
    // @return nothing  
    void set(int key, int value) {  
        // write your code here  
 
        if(m.find(key)==m.end())  
        {          
            if(head==NULL)  
                {  
                    head = new Node(key,value);  
                    tail = head;  
                    size++;  
                    m[key] = head;  
                    return;  
                } 
            Node*n = new Node(key,value);  
            insert(n);  
            m[key] = n;  
            size++;
            if(size>capacity)  
                {  
                    Node*todel = tail;  
                    int keyToDel = todel->key;  
                    tail = tail->pre;  
                    tail->next = NULL;  
                    delete todel;  
                    m.erase(m.find(keyToDel));  
                    size--;  
                } 
        }  
        else  
        {  
            Node*n = m[key];  
            if(head!=n)  
            {  
                remove(n);
                insert(n);
                //m[key] = n;  
            }  
            head->value = value;  
        }  
 
          
    }  

    private:  
          void remove(Node* n){
          if (n == tail) {
              tail = n->pre;
              tail->next = NULL;
          } else {
              n->pre->next = n->next;
              n->next->pre = n->pre;
          }
      }
      void insert(Node* n){
          n->next = head;
          head->pre = n;
          head = n;
      }
      
        int capacity;  
        int size;  
        Node*head;  
        Node*tail;  
        unordered_map<int,Node*> m;
        
};