LRU（最近最少使用）算法实现

核心思想与基本思路

LRU（Least Recently Used）算法是一种缓存淘汰策略，其核心思想是淘汰最近最少使用的数据。

• 最近使用原则：最近被访问的数据在未来被访问的概率更高，因此应保留在缓存中。
• 淘汰机制：当缓存容量满时，淘汰最久未被访问的数据。

那LRU是怎么判断哪个数据是最近最少使用的呢？可能每个数据被访问的时候，记录一个时间戳或者顺序，然后淘汰最久没有被访问的那个。比如，如果有几个数据，每次访问的时候都更新它们的最近使用时间，当需要淘汰的时候，找时间最早的那个。那具体怎么实现呢？

举个例子吧，假设缓存容量是3，现在依次访问数据A、B、C。那么缓存中的顺序是A→B→C，链表头是C，尾是A。这时候缓存满了。如果再访问D，就需要淘汰最久未使用的A，然后加入D，链表变成D→C→B？或者我可能弄反了顺序？比如每次访问的时候，把节点移动到链表头部，所以最近访问的在头部，最久未使用的在尾部。假设现在缓存中有A、B、C，顺序是C是最近访问的，所以链表头是C，然后是B，然后是A。当访问B时，要把B移动到头部，这时候顺序变成B→C→A。这时候链表尾部是A。如果这时候要插入D，就淘汰A，然后D插入头部，变成D→B→C。对吗？

进一步地，我们可以将LRU算法想象成对一堆书进行操作。

对于需要访问某本书时，则将书堆中的某本书取出并放在最上面，当书的数量超过某个值时（也就是超过缓存容量时），我们则将最下面一本书抽出，并将新的书放在书堆的最上面。这也就是最简单的LRU算法基本原理。

有了上述思路，那么我们该如何实现LRU算法的get 和put 操作呢？
很简单

实现方式

使用哈希表和双向链表结合的数据结构

• 哈希表：提供O(1)时间的键值查询，存储键到链表节点的映射。

• 双向链表：维护数据的访问顺序，最近访问的节点靠近头部，最久未访问的节点靠近尾部。

操作步骤

• 访问数据（get）：
  若键存在，通过哈希表定位节点，将其移动到链表头部，表示最近使用，返回节点值。
  若键不存在，返回-1。

• 插入数据（put）：
  若键存在，更新值并将节点移动到链表头部。
  若键不存在，创建新节点并插入链表头部。若缓存已满，删除链表尾部节点（最久未使用），并在哈希表中移除对应键。

复杂度分析

• 时间复杂度：get和put操作均为O(1)。

• 空间复杂度：O(capacity)，用于存储哈希表和链表。

为了便于双向链表的维护与访问，我们可以设置一个头结点，当需要get和put书堆中的某本书时，直接用头插法将结点移动到第一个结点即可。
实现代码如下：

class Node {
public:
    int key; 
    int value;
    Node *next;
    Node *prev;
    Node(int k = 0, int v = 0) : key(k), value(v) {}
};
class LRUCache {
private:
    int capacity;
    Node *cache; // 头结点
    unordered_map <int, Node*> key_to_node;

    void RemoveNode(int key) {
        Node *node = key_to_node[key];
        node -> prev -> next = node -> next;
        node -> next -> prev = node -> prev;
        key_to_node.erase(key);
        delete node;
    }

    void PushFront(Node *node) { // 头插法
        node -> next = cache -> next;
        node -> prev = cache;
        cache -> next -> prev = node;
        cache -> next = node;
        key_to_node[node -> key] = node;
    }
public:
    LRUCache(int capacity) {
        this -> capacity = capacity;
        cache = new Node;
        cache -> next = cache -> prev = cache;
    }
    
    int get(int key) {
        if(key_to_node.find(key) != key_to_node.end()) {
            int value = key_to_node[key] -> value;
            RemoveNode(key);
            Node *node = new Node(key, value);
            PushFront(node);
            return value;
        }
        return -1; 
    }
    
    void put(int key, int value) {
        auto find_key = key_to_node.find(key);
        Node *node = new Node(key, value);
        if(find_key == key_to_node.end()) {
            if(key_to_node.size() < capacity) {
                PushFront(node);
            } else {
                RemoveNode(cache -> prev -> key);
                PushFront(node);
            }
        } else { // 如果key值已经存在，就变更value值再插入到第一个节点中。
            RemoveNode(key);
            PushFront(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);
 */