LeetCode 146. LRU 缓存

题目链接：https://leetcode-cn.com/problems/lru-cache/

缓存（Cache）是一种提高数据读取性能的技术，在硬件设计、软件开发中有着广泛的应用，比如常见的CPU缓存、数据库缓存、浏览器缓存等等。

缓存的大小是有限的。当缓存被用满时，哪些数据应该被清理出去，哪些数据应该被保留，这就需要用到缓存淘汰策略。

FIFO（First In First Out），先进先出策略

思想：如果一个数据是最先进入的，那么可以认为在将来它被访问的可能性很小。空间满的时候，最先进入的数据会被最早淘汰掉。

LFU（Least Frequently Used），最近最少使用策略

思想：如果一个数据在最近一段时间很少被访问到，那么可以认为在将来它被访问的可能性也很小。因此，当空间满时，最小频率访问的数据最先被淘汰。

LRU（Least Recently Used），最近最久未使用策略

思想：如果一个数据在最近一段时间没有被访问到，那么可以认为在将来它被访问的可能性也很小。因此，当空间满时，最久没有访问的数据最先被淘汰。

总体思路：将最近使用的元素存放到靠近缓存顶部的位置，当一个新条目被访问时，LRU 将它放置到缓存的顶部。当缓存满时，较早之前访问的条目将从缓存底部被移除。

class LRUCache {
private:
    struct Node {
        int key, value;
        Node *prev, *next;
        Node(int _key, int _value) : key(_key), value(_value), prev(nullptr), next(nullptr) {}
    };
    Node *first, *last;
    unordered_map hash;
    int capacity;

    void removeNode(Node *p) {
        p->next->prev = p->prev;
        p->prev->next = p->next;
    }

    void addAfterFirst(Node *p) {
        p->next = first->next;
        first->next->prev = p;

        p->prev = first;
        first->next = p;
    }

public:
    LRUCache(int capacity) {
        this->capacity = capacity;
        first = new Node(-1, -1);
        last = new Node(-1, -1);
        first->next = last;
        last->prev = first;
    }
    
    int get(int key) {
        if (hash.count(key) == 0)   return -1;

        auto p = hash[key];
        removeNode(p);
        addAfterFirst(p);
        return p->value;
    }
    
    void put(int key, int value) {
        if (hash.count(key)) {
            auto p = hash[key];
            p->value = value;
            removeNode(p);
            addAfterFirst(p);
        } else {
            if (hash.size() == capacity) {
                auto p = last->prev;
                removeNode(p);
                hash.erase(p->key);
                delete p;
            }
            auto node = new Node(key, value);
            hash[key] = node;
            addAfterFirst(node);
        }
    }
};