[leetcode] 146.LRU Cache

题目：
Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
set(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.
题意：
设计一个LRU cache，即最近最少使用的cache。
get(key)函数来查看是否有该key值的条目，如果有的话返回对应的value值，否则返回-1；
set(key, value)函数用来插入或者改变对应的键值对。如果插入时cache已经达到了最大值容量，那么移除最近最少使用的那个条目，然后插入该条目。
需要注意的是，无论是修改或者更新或者插入一个条目，该条目就变成了最近使用的条目。
需要考虑的因素包括查找该key对应的value值，或者改变该key对应的value值或者增加键值对。需要记录的是使用情况的顺序，每次这三个操作的条目应该变成最近使用的那个条目。当涉及到查找时，应该考虑到使用hash来帮助查找。所以用一个unordered_map来记录每个key对应的条目。条目我们用一个struct来表示。所以每个在unordered_map中，每个key对应了一个struct条目。接下来考虑的是需要更新条目最近使用的位置。所以我们使用链表保存这些条目，一旦条目被最近使用，那么放到链表的最前端。如果插入条目时满了，那么删除最后一个条目。
所以总结起来，使用两个数据结构，一个是unordered_map来保存key值以及在链表中对应的条目，另一个是链表，来记录条目的先后顺序。
综上所述。
代码如下：

struct Node
{
    int key;
    int value;
    Node* next;
    Node* prev;
    Node(int k, int v) :key(k), value(v), next(NULL), prev(NULL) {}
};
class LRUCache
{
private:
    unordered_map<int, Node*> key_node;
    Node* nodes_head;
    Node* nodes_tail;
    int capacity;
    int size;
public:
    LRUCache(int capacity)
    {
        this->capacity = capacity;
        size = 0;
        nodes_head = NULL;
        nodes_tail = NULL;
    }

    int get(int key)
    {
        if (key_node.find(key) == key_node.end())
            return -1;
        else
        {
            Node* tmp = key_node[key];
            reSetHead(tmp);
            return tmp->value;
        }

    }

    void set(int key, int value)
    {
        if (key_node.find(key) != key_node.end())
        {
            Node* tmp = key_node[key];
            reSetHead(tmp);
            nodes_head->value = value;
        }
        else
        {
            if (size < capacity)
            {
                Node* tmp = new Node(key, value);
                key_node[key] = tmp;

                if (nodes_head == NULL)
                {
                    nodes_head = nodes_tail = tmp;
                }
                else
                {
                    tmp->next = nodes_head;
                    nodes_head->prev = tmp;
                    nodes_head = tmp;
                }
                size++;
            }
            else
            {
                Node* tmp = new Node(key, value);
                key_node[key] = tmp;

                Node* last = nodes_tail;
                key_node.erase(last->key);

                if (last == nodes_head)
                {
                    delete last;
                    nodes_head = nodes_tail = tmp;
                }
                else
                {
                    last->prev->next = NULL;
                    nodes_tail = last->prev;
                    delete last;
                    tmp->next = nodes_head;
                    nodes_head->prev = tmp;
                    nodes_head = tmp;
                }
            }
        }
    }
    void reSetHead(Node* tmp)
    {   
        if (tmp != nodes_head)
        {
            if (tmp == nodes_tail) nodes_tail = tmp->prev;
            tmp->prev->next = tmp->next;
            if (tmp->next != NULL)
            {
                tmp->next->prev = tmp->prev;
            }
            tmp->next = nodes_head;
            tmp->prev = NULL;
            nodes_head->prev = tmp;
            nodes_head = tmp;
        }
    }
};