LeetCode 146. LRU 缓存机制

难度：中等。
标签：设计，哈希表，链表，双向链表。

想到了要用哈希表和双向链表。
但具体不想想了，累了。看题解吧。

一下代码get和put和初始化函数是照着教程写的，moveToHead，addToHead，removeTail是自己写的。注意第18行，一定要判断当前节点是否已经在头部，如果在就直接返回。

正确解法：

struct DLinkedNode{
        int key, val;
        DLinkedNode* prev, *next;
        DLinkedNode():key(0), val(0), prev(nullptr), next(nullptr){}
        DLinkedNode(int k, int v):key(k), val(v), prev(nullptr), next(nullptr){}
    };


class LRUCache {
    unordered_map<int, DLinkedNode*> cache;
    DLinkedNode* head;
    DLinkedNode* tail;
    int size;
    int capacity;

    void moveToHead(DLinkedNode* node){
        DLinkedNode* temp = head->next;
        if(node == temp)return;
        DLinkedNode* node_prev = node->prev;
        DLinkedNode* node_next = node->next;
        head->next = node;
        node->next = temp;
        node->prev = head;
        temp->prev = node;
        node_prev->next = node_next;
        node_next->prev = node_prev;
    }


    void addToHead(DLinkedNode* node){
        DLinkedNode* temp = head->next;
        head->next = node;
        node->next = temp;
        node->prev = head;
        temp->prev = node;
    }

    DLinkedNode* removeTail(){
        DLinkedNode* removed = tail->prev;
        DLinkedNode* last_node = removed->prev;
        tail->prev = last_node;
        last_node->next = tail;
        return removed;
    }
    
public:
    LRUCache(int c) {
        capacity = c;
        size = 0;
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head->next = tail;
        tail->prev = head;
    }
    
    int get(int key) {
        if(!cache.count(key))return -1;
        DLinkedNode* node = cache[key];
        moveToHead(node);
        return node->val;
    }
    
    void put(int key, int value) {
        if(!cache.count(key)){
            if(size == capacity){
                DLinkedNode* removed = removeTail();
                cache.erase(removed->key);
                delete removed;
                --size;
            }
            DLinkedNode* node = new DLinkedNode(key, value);
            cache[key] = node;
            addToHead(node);
            ++size;
        }
        else{
            DLinkedNode* node = cache[key];
            node->val = value;
            moveToHead(node);
        }

    }
};

结果：