Leetcode146. LRU 缓存 -hot100

题目：

---

代码(首刷看解析 2024年3月5日）：

        学的灵神，太优美了，这个哨兵节点思想

class Node {
public:
    int key,value;
    Node* prev,*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->prev->next = x->next;
        x->next->prev = x->prev;
    }
    void push_front(Node *x) {
        x->next = dummy->next;
        x->prev = dummy;
        x->prev->next = x;
        x->next->prev = x;
    }
    Node* get_node(int key) {
        auto it = key_to_node.find(key); 
        if (it == key_to_node.end())
            return nullptr;
        auto node = it->second;
        remove(node);
        push_front(node);
        return node;
    }
public:
    LRUCache(int capacity) : capacity(capacity) , dummy(new Node){
        dummy->prev = dummy;
        dummy->next = dummy;
    }
    
    int get(int key) {
        auto node = get_node(key);
        return node ? node->value : -1;
    }
    
    void put(int key, int value) {
        auto 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) {
            auto back_node = dummy->prev;
            key_to_node.erase(back_node->key);
            remove(back_node);
            delete back_node;
        }
    }
};

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache* obj = new LRUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */

---

代码（二刷看解析 2024年4月14日）

struct Node{
    int key;
    int value;
    Node* prev;
    Node* next;
    Node(int k = 0, int v = 0) : key(k), value(v){}
};

class LRUCache {
protected:
    Node* dummyHead;
    int _capacity;
    unordered_map<int,Node*> key_to_node;
private:
    void remove(Node* cur) {
        cur->prev->next = cur->next;
        cur->next->prev = cur->prev;
    }
    void push_front(Node* cur) {
        cur->next = dummyHead->next;
        cur->prev = dummyHead;
        cur->next->prev = cur;
        cur->prev->next = cur;
    }
    Node* get_node(int key) {
        auto it = key_to_node.find(key);
        if (it == key_to_node.end()) {
            return nullptr;
        }
        remove(it->second);
        push_front(it->second);
        return it->second;
    }
    
public:
    LRUCache(int capacity):_capacity(capacity), dummyHead(new Node) {
        dummyHead->next = dummyHead;
        dummyHead->prev = dummyHead;
    }
    
    int get(int key) {
        auto node = get_node(key);
        return node == nullptr ? -1 : node->value;
    }
    
    void put(int key, int value) {
        // 不存在，则创建
        auto 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* tmp = dummyHead->prev;
            key_to_node.erase(tmp->key);
            remove(tmp);
            delete tmp;   
        }
    }
};