LeetCode146. LRU 缓存实现（HashMap+双向链表）【重点数据结构】

在C语言实验的很多代码中都会使用到LRU最近最少使用 算法，如在操作系统中对空闲区域的调度，同时算法一般还伴随着对操作读写删操作O(1)时间复杂度要求，以提高系统相应速度。

题目

https://leetcode.cn/problems/lru-cache/

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。
实现 LRUCache 类：

• LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
• int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
• void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

示例：

输入

["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]

输出

[null, null, null, 1, null, -1, null, -1, 3, 4]

解释

LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1);    // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2);    // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1);    // 返回 -1 (未找到)
lRUCache.get(3);    // 返回 3
lRUCache.get(4);    // 返回 4

提示：

1 <= capacity <= 3000
0 <= key <= 10000
0 <= value <= 10^5
最多调用 2 * 10^5 次 get 和 put

算法实现

LRU 缓存机制可以通过哈希表+双向链表实现：

• 双向链表按照被使用的顺序存储了这些键值对，从头到位是按照最近使用距离排序，当查询或插入此值就是最近使用的数据，提前到头部节点，实现LRU功能。
• 哈希表即为普通的哈希映射（HashMap），通过缓存数据的键映射到其在双向链表中的位置，实现O(1)的查找。

注意：

• 其实链表结构就能实现LRU，使用双向链表是为了方便删除最久未使用的尾结点更高效
• 同时可以使用一个伪头部和伪尾部标记界限，这样在添加节点和删除节点的时候就不需要检查相邻的节点是否存在

实现逻辑：

• 查询：
  • 若hashmap中不存在此key，返回-1;
  • 若存在此key，用hashmap得到节点，将节点从当前位置删除，然后插入到头结点位置
• 插入：
  • 若hashmap存在此key,直接将hashmap对应的节点内容改为插入值，并将节点插入头位置
  • 若hashmap不存在此key
    • 当容量未满，创建一个节点，插入到头结点位置，节点数+1
    • 当容量满了，将尾结点提取出来插入到头结点位置，value改为插入值

时间复杂度分析：

• hashmap查找节点：O(1)
• 删除链表节点：O(1)
• 插入链表节点：O(1)

代码实现

class LRUCache {
public:
    struct Node{
        int val;
        int key; // 存储key是为了方便删除map中映射
        Node* pre;
        Node* next;
    };

    Node* head;
    Node* tail; 
    int cap; // 容量
    int cnt; // 已有的数量
    unordered_map<int, Node*> mp;

    LRUCache(int capacity) {
        cap = capacity;
        cnt = 0;
        head = new Node;
        tail = new Node;
        head->next = tail;
        head->pre = tail;
        tail->pre = head;
        tail->next = head;
        cout<<"LRUCache"<<endl;
    }
    
    int get(int key) {
        if(!mp.count(key)){
            // 找不到该key 
            return -1;
        }
        // 找得到，则将该节点移到链表首
        Node* cur = mp[key];
        // 提取出此节点
        cur->pre->next = cur->next;
        cur->next->pre = cur->pre;
        // 插入链表首
        cur->pre = head;
        cur->next = head->next;
        head->next = cur;
        cur->next->pre = cur;
        cout<<"get"<<endl;
        return cur->val; 
    }
    
    void put(int key, int value) {
        Node* cur; // 新插入的节点

        // 构造新插入的节点（通过复用或者新建），复用需要清理原有关系
        // 首先查看该值是否存在
        if(mp.count(key)){
            // 找该key,直接替换值，用此节点复用作为新的值存储
            cur = mp[key];
            // 提取出此节点
            cur->pre->next = cur->next;
            cur->next->pre = cur->pre;
            // 无需改变map映射
        }
        else{
            // 该值不存在，查看容量
            if(cnt == cap){
                // 满了，替换LRU，最后一个节点将被删除，这里直接用作新节点
                Node* cur = tail->pre;
                // 提取出此节点
                cur->pre->next = cur->next;
                cur->next->pre = cur->pre;
                // 更改原来映射
                mp.erase(cur->key);
                mp[key] = cur;
            }
            else{
                // 容量未满，创建一个节点
                cur = new Node;
                // 增加容量
                cnt++;
                // 添加映射
                mp[key] = cur;
            }
        }

        // 存入值
        cur->val = value;
        // 存入key
        cur->key = key;
        // 插入链表首
        cur->next = head->next;
        cur->pre = head;
        cur->next->pre = cur;
        head->next = cur;
    }
};