力扣：146.LRU 缓存

1. LRU Least Recently Used
2. cache 对速度要求严苛，是常数时间
3. put 的要求是找到了就更新值，没找到就插入值
4. cache 里面的 key 和 Node* 里面的 key 是同一个 key

class LRUCache {
public:
    LRUCache(int capacity) {
        this->capacity = capacity;
        this->size = 0;
        head = new Node( 0, 0 );
        tail = new Node( 0, 0 );
        head->next = tail;
        tail->prev = head;
    }
    
    int get(int key) {
        if ( cache.find( key ) == cache.end() ) return -1;
        Node *node = cache[key];
        moveToHead( node );
        return node->val;
    }
    
    void put(int key, int value) {
        if ( cache.find( key ) != cache.end() ) {
            Node *node = cache[key];
            node->val = value;
            moveToHead( node );
        } else {
            Node *newNode = new Node( key, value );
            cache[key] = newNode;
            addToHead( newNode );
            size++;
            if ( size > capacity ) {
                Node *tailNode = removeTail();
                cache.erase( tailNode->key );
                delete tailNode;
                size--;
            }
        }
    }
private:
    struct Node {
        int key, val;
        Node *prev, *next;
        Node( int k, int v ) : key(k), val(v), prev(nullptr), next(nullptr) {}
    };
    int capacity;
    int size;
    Node *head, *tail;
    unordered_map<int, Node*> cache;
    void removeNode( Node *node ) {
        node->prev->next = node->next;
        node->next->prev = node->prev;
    }
    void addToHead( Node *node ) {
        node->next = head->next;
        node->prev = head;
        head->next->prev = node;
        head->next = node;
    }
    void moveToHead( Node *node ) {
        removeNode( node );
        addToHead( node );
    }
    Node *removeTail() {
        Node *res = tail->prev;
        removeNode( res );
        return res;
    }
};