HOT100(链表)

链表

146.LRU缓存

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构get和put。
思路：首先在LRU cache中实现一个基础的增删查功能，然后再实现get和put最近最少的功能（末尾节点）

class Node {
public:
    int key;
    int value;
    Node* pre;
    Node* next;
    Node(int k = 0, int v = 0):key(k), value(v){}
};
class LRUCache {
private:
    int capacity;
    Node* dummy;
    unordered_map<int, Node*> key_to_node;
    void remove(Node* X) {
        X->pre->next = X->next;
        X->next->pre = X->pre;
    }
    void push_front(Node* X){
        X->pre = dummy;
        X->next = dummy->next;
        X->pre->next = X;
        X->next->pre = X;
    }
    Node* get_node(int key){
        auto it = key_to_node.find(key);
        if(it == key_to_node.end()){
            return nullptr;
        }
        Node* node = it->second;
        remove(node);
        push_front(node);
        return node;
    } 
public:
    LRUCache(int capacity):capacity(capacity),dummy(new Node()) {
        dummy->next = dummy;
        dummy->pre = dummy;
    }
    int get(int key) {
        Node* node = get_node(key);
        if(node) return node->value;
        return -1;
    }
    void put(int key, int value) {
        Node* node = get_node(key);
        if(node) {
            node->value = value;
            return;
        }
        node = new Node(key, value);
        key_to_node[key] = node;
        push_front(node);
        if(key_to_node.size() > capacity) {
            Node* back_node = dummy->pre;
            key_to_node.erase(back_node->key);
            remove(back_node);
            delete back_node;
        }
        return;
    }

};