本文主要是介绍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 <= 105
- 最多调用 2 * 105 次 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; // 返回 1cache.put(2, 2);std::cout << "Get 2: " << cache.get(2) << std::endl; // 返回 2cache.put(3, 3); // 淘汰键 1 使用 putstd::cout << "Get 1: " << cache.get(1) << std::endl; // 返回 -1 (未找到)std::cout << "Get 3: " << cache.get(3) << std::endl; // 返回 3cache.put(4, 4); // 淘汰键 2 使用 putstd::cout << "Get 2: " << cache.get(2) << std::endl; // 返回 -1 (未找到)cache.put(2, 6); // 重新添加键 2std::cout << "Get 2: " << cache.get(2) << std::endl; // 返回 6return 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; // 返回 1cache.put(2, 2);std::cout << cache.get(2) << std::endl; // 返回 2cache.put(3, 3); // 淘汰键 1std::cout << cache.get(1) << std::endl; // 返回 -1 (未找到)std::cout << cache.get(3) << std::endl; // 返回 3cache.put(4, 4); // 淘汰键 2std::cout << cache.get(2) << std::endl; // 返回 -1 (未找到)return 0;
}
这个示例展示了 LRU 缓存的基本操作,包括 get
和 put
方法。get
方法用于访问缓存中的项,而 put
方法用于添加或更新缓存中的项。如果缓存达到容量限制,put
方法还会淘汰最不常使用的项。
这篇关于LeetCode 算法:LRU 缓存 c++的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!