LRU缓存策略-LintCode

为最近最少使用（LRU）缓存策略设计一个数据结构，它应该支持以下操作：获取数据（get）和写入数据（set）。
获取数据get(key)：如果缓存中存在key，则获取其数据值（通常是正数），否则返回-1。
写入数据set(key, value)：如果key还没有在缓存中，则写入其数据值。当缓存达到上限，它应该在写入新数据之前删除最近最少使用的数据用来腾出空闲位置。

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)
            {
                if(n==tail)
                    tail = tail->pre;
                Node*pre = n->pre;
                if(n->next!=NULL)
                    n->next->pre = pre;
                pre->next = n->next;
                n->next = head;
                head->pre = n;
                head = n;
            }
            return ret;
        }
    }

    // @param key, an integer
    // @param value, an integer
    // @return nothing
    void set(int key, int value) {
        // write your code here
        if(head==NULL)
        {
            head = new Node(key,value);
            tail = head;
            size++;
            m[key] = head;
            return;
        }
        if(m.find(key)==m.end())
        {
            Node*n = new Node(key,value);
            n->next = head;
            head->pre = n;
            head = n;
            m[key] = n;
            size++;
        }
        else
        {
            Node*n = m[key];
            if(head!=n)
            {
                if(n==tail)
                    tail = tail->pre;
                Node*pre = n->pre;
                pre->next = n->next;
                if(n->next!=NULL)
                    n->next->pre = pre;
                n->next = head;
                head->pre = n;
                head = n;
                m[key] = n;
            }
            head->value = value;
        }
        if(size>capacity)
        {
            Node*todel = tail;
            int keyToDel = todel->key;
            tail = tail->pre;
            tail->next = NULL;
            delete todel;
            m.erase(m.find(keyToDel));
            size--;
        }

    }

    private:
        int capacity;
        int size;
        Node*head;
        Node*tail;
        unordered_map<int,Node*> m;
};