题目
请你设计并实现一个满足 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
题解
LRU (最近最少使用) 缓存
LRU,Least Recently Used算法,即一种缓存淘汰策略。计算机的缓存容量有限,若缓存满了则需要删除一些内容,给新的缓存腾出空间,但问题是要删除哪些内容呢?这需要相应的缓存策略来实现。
缓存淘汰的策略有很多,而LRU则是一种较为简单常用的算法,LRU判定最近使用过的数据为有用的,很久都没用过的数据是无用的,在内存满了就优先删除很久未使用,也就是无用的数据。
解题思路
本题的关键在于数据增加,查找时都需要改变所有数据的优先级,要在O(1)的复杂度内实现,显然需要用到链表+map的组合,为快速实现链表结点查找与修改,需要使用到双向链表。
因此,解题方法为:“map+双向链表”,map保存键值为数据的key与双向链表结点,便于快速查找对应结点。双向链表维护了数据的优先级信息,优先级最高的在最前,最低在最后。具体的,设置两个哨兵结点——>哨兵头结点(head)与哨兵尾结点(tail),便于发生插入/删除操作时的操作。
代码
// 双向链表 + map
// 双向链表维护数据使用的次序,最久未使用在最前,最新在最后
// 构建双向链表类,记录缓存优先级信息
class DlinkNode
{
public:
DlinkNode* prev;
DlinkNode* next;
int key, value;
DlinkNode():prev(nullptr), next(nullptr), key(0), value(0){}
DlinkNode(int key_, int value_):prev(nullptr), next(nullptr), key(key_), value(value_){}
};
class LRUCache {
public:
LRUCache(int capacity_):capacity(capacity_), size(0)
{
// head, tail哨兵节点, head->next 为头节点, tail->prev为尾节点
head = new DlinkNode();
tail = new DlinkNode();
head->next = tail;
tail->prev = head;
}
int get(int key) {
// 如果存在,将结点挪到头部
if(mp.count(key))
{
DlinkNode* node = mp[key];
move2Head(node);
return node->value;
}
return -1;
}
void put(int key, int value) {
if(!mp.count(key))
{
// 不存在,创建新节点,添加进哈希表并放入表头
DlinkNode* node = new DlinkNode(key, value);
add2Head(node);
mp[key] = node;
size++;
if(size > capacity)
{
// 超出容量,删除尾部
DlinkNode* removed = removeTail();
mp.erase(removed->key);
delete removed;
size--;
}
}
else
{
DlinkNode* node = mp[key];
node->value = value;
move2Head(node);
}
}
void add2Head(DlinkNode* node)
{
node->prev = head;
node->next = head->next;
head->next->prev = node;
head->next = node;
}
void removeNode(DlinkNode* node)
{
node->prev->next = node->next;
node->next->prev = node->prev;
}
void move2Head(DlinkNode* node)
{
removeNode(node);
add2Head(node);
}
// 删除最后的结点,及tail前的结点
DlinkNode* removeTail()
{
DlinkNode* node = tail->prev;
removeNode(node);
return node;
}
private:
int size;
int capacity;
map<int, DlinkNode*> mp;
DlinkNode* head;
DlinkNode* tail;
};