LeetCode 算法：LRU 缓存 c++

原题链接🔗：
难度：中等⭐️⭐️

题目

请你设计并实现一个满足 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⁵
最多调用 2 * 10⁵ 次 get 和 put

题解

解题思路：

LeetCode 上的 LRU 缓存问题（题目编号 146）要求我们实现一个 LRU 缓存类，该类支持两种操作：get 和
put。以下是解决这个问题的一般思路：

理解问题：
get(key): 从缓存中获取键对应的值（如果存在）。缓存中键的最近使用时间应该被更新为当前时间。 -
put(key, value): 向缓存中插入或更新键和值。如果键已存在，则更新其值并更新其使用时间。如果键不存在，并且缓存已满，则需要先移除最久未使用的键。

设计数据结构：为了实现 LRU 缓存，我们需要两个主要的数据结构：
哈希表：存储键到值的映射，以及键到双向链表中节点的引用，以便 O(1) 时间复杂度的访问。
双向链表：存储缓存项的顺序，最近使用的项在头部，最久未使用的项在尾部。

算法实现：
初始化：创建一个固定大小的哈希表和空的双向链表。
get(key)：检查键是否存在于哈希表中。如果存在，移动该键关联的节点到双向链表的头部，表示最近使用。返回键对应的值。如果不存在，返回 -1。
put(key, value)：
如果键已存在于哈希表中，更新其值，并将节点移动到双向链表的头部。
如果键不存在：
如果缓存未满，创建新节点，添加到双向链表的头部，并在哈希表中添加键到节点的映射。
如果缓存已满，从双向链表尾部移除最久未使用的节点，并从哈希表中删除对应的键。
然后，创建新节点，添加到双向链表的头部，并更新哈希表。

复杂度：时间复杂度O(1)，空间复杂度O(capacity)。
c++ demo：

#include <iostream>
#include <unordered_map>
#include <list>

class LRUCache {
private:
    int capacity;
    std::list<int> items; // 双向链表，存储键
    std::unordered_map<int, std::list<int>::iterator> cache; // 哈希表，存储键到链表迭代器的映射

    void moveToHead(int key) {
        items.splice(items.begin(), items, cache[key]); // 将节点移动到头部
    }

    void removeLeastRecent() {
        if (!items.empty()) {
            cache.erase(items.back()); // 从哈希表中删除
            items.pop_back(); // 从链表中删除
        }
    }

public:
    LRUCache(int capacity) : capacity(capacity) {}

    int get(int key) {
        if (cache.find(key) != cache.end()) {
            moveToHead(key);
            return items.front();
        }
        else {
            return -1; // 键不存在
        }
    }

    void put(int key, int value) {
        if (cache.find(key) != cache.end()) {
            items.erase(cache[key]); // 从链表中删除旧节点
            cache.erase(key);
        }
        if (items.size() >= capacity) {
            removeLeastRecent(); // 检查是否需要淘汰
        }
        items.push_front(key); // 添加新节点到头部
        cache[key] = items.begin(); // 更新哈希表
    }
};

int main() {
    LRUCache cache(2);

    cache.put(1, 1);
    std::cout << "Get 1: " << cache.get(1) << std::endl; // 返回 1
    cache.put(2, 2);
    std::cout << "Get 2: " << cache.get(2) << std::endl; // 返回 2
    cache.put(3, 3); // 淘汰键 1 使用 put
    std::cout << "Get 1: " << cache.get(1) << std::endl; // 返回 -1 (未找到)
    std::cout << "Get 3: " << cache.get(3) << std::endl; // 返回 3
    cache.put(4, 4); // 淘汰键 2 使用 put
    std::cout << "Get 2: " << cache.get(2) << std::endl; // 返回 -1 (未找到)
    cache.put(2, 6); // 重新添加键 2
    std::cout << "Get 2: " << cache.get(2) << std::endl; // 返回 6

    return 0;
}

输出结果：

Get 1: 1
Get 2: 2
Get 1: -1
Get 3: 3
Get 2: -1
Get 2: 2

LRU 缓存

LRU（Least Recently Used）缓存是一种常用的缓存淘汰策略，它基于一个原则：如果数据最近被访问过，那么将来被访问的几率也更高。LRU 缓存通常用于操作系统、数据库、Web 服务器等场景，以减少内存或存储的使用，同时保持最常访问的数据可用。

LRU 缓存的实现

实现 LRU 缓存的一种常见方法是使用哈希表和双向链表。哈希表提供了 O(1) 的访问时间复杂度，而双向链表则允许我们以 O(1) 的时间复杂度进行数据的添加和删除操作。

数据结构

哈希表：存储键和对应节点的指针，以便快速访问。
双向链表：存储缓存中的项，最近使用的项在头部，最不常使用的项在尾部。

操作

访问缓存：
- 检查键是否存在于哈希表中。
- 如果存在，将对应的节点移动到双向链表的头部。
- 如果不存在，根据需要从链表尾部移除一个节点（如果缓存已满），然后将新节点添加到头部。
添加到缓存：
- 如果键已存在，更新其值，并将节点移动到链表头部。
- 如果键不存在，创建新节点，添加到链表头部，并在哈希表中记录。
淘汰缓存：
- 当缓存达到容量限制时，从链表尾部移除最不常使用的项，并从哈希表中删除相应的键。

示例代码

以下是使用 C++ 实现的 LRU 缓存的简单示例：

#include <iostream>
#include <list>
#include <unordered_map>

class LRUCache {
private:
    int capacity;
    std::list<int> items; // 双向链表，存储键
    std::unordered_map<int, std::list<int>::iterator> cache; // 哈希表，存储键到链表迭代器的映射

    void moveToHead(int key) {
        items.splice(items.begin(), items, cache[key]); // 将节点移动到头部
    }

    void removeLeastRecent() {
        if (items.size() > capacity) {
            cache.erase(items.back()); // 从哈希表中删除
            items.pop_back(); // 从链表中删除
        }
    }

public:
    LRUCache(int capacity) : capacity(capacity) {}

    int get(int key) {
        if (cache.find(key) != cache.end()) {
            moveToHead(key);
            return items.front();
        } else {
            return -1; // 键不存在
        }
    }

    void put(int key, int value) {
        if (cache.find(key) != cache.end()) {
            items.erase(cache[key]); // 从链表中删除旧节点
        } else {
            removeLeastRecent(); // 检查是否需要淘汰
        }
        items.push_front(key); // 添加新节点到头部
        cache[key] = items.begin(); // 更新哈希表
    }
};

int main() {
    LRUCache cache(2);
    cache.put(1, 1);
    std::cout << cache.get(1) << std::endl; // 返回 1
    cache.put(2, 2);
    std::cout << cache.get(2) << std::endl; // 返回 2
    cache.put(3, 3); // 淘汰键 1
    std::cout << cache.get(1) << std::endl; // 返回 -1 (未找到)
    std::cout << cache.get(3) << std::endl; // 返回 3
    cache.put(4, 4); // 淘汰键 2
    std::cout << cache.get(2) << std::endl; // 返回 -1 (未找到)
    return 0;
}