LRU缓存机制
运用你所掌握的数据结构,设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作: 获取数据 get 和 写入数据 put 。
获取数据 get(key) - 如果关键字 (key) 存在于缓存中,则获取关键字的值(总是正数),否则返回 -1。
写入数据 put(key, value) - 如果关键字已经存在,则变更其数据值;如果关键字不存在,则插入该组「关键字/值」。当缓存容量达到上限时,它应该在写入新数据之前删除最久未使用的数据值,从而为新的数据值留出空间。
进阶:
你是否可以在 O(1) 时间复杂度内完成这两种操作?
示例
LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );
cache.put(1, 1);
cache.put(2, 2);
cache.get(1); // 返回 1
cache.put(3, 3); // 该操作会使得关键字 2 作废
cache.get(2); // 返回 -1 (未找到)
cache.put(4, 4); // 该操作会使得关键字 1 作废
cache.get(1); // 返回 -1 (未找到)
cache.get(3); // 返回 3
cache.get(4); // 返回 4
分析
分析上面的操作过程,要让 put 和 get 方法的时间复杂度为 O(1),我们可以总结出 这个数据结构必要的条件:查找快,插入快,删除快,有顺序之分
新的数据结构必须有顺序之分,以区分最近使用的和久未使用的数据;而且我们要在 数据结构中查找键是否已存在;如果容量满了要删除最后一个数据;每次访问还要把数据插入到队头。
看到Key-value 对应关系 第一点想到的是要用到哈希表,这点应该没有异议,因为哈希表满足查找数据时间复杂度O(1)的要求,在这点上,vector也是可以满足要求,但是难就难在第二点要求了,插入和删除也得满足O(1)要求这时候vector就不行了,只能考虑到双向链表,所以现在初步定下来就是哈希表+双向链表的组合了。
就是借助哈希表赋予了链表快速查找的特性:可以快速查找某个 key 是否存在缓存(链表)中,同时可以快速删除、添加节点。回想刚才的例子,这种数据结构是不是完美解决了 LRU 缓存的需求
struct Node
{
int key;
int value;
Node* pre;
Node* next;
// 构造函数初始化
Node(int key, int value) : key(key), value(value), pre(nullptr), next(nullptr){
}
};
class LRUCache {
private:
int size;// 缓冲区大小
Node* head;
Node* tail;
map<int, Node*> p;
public:
LRUCache(int capacity) {
this->size = capacity;
head = nullptr;
tail = nullptr;
}
// 获取缓冲区中 key 对应的 value
int get(int key) {
// 1.当该 key 值存在
if(p.count(key) > 0)
{
// 删除该 key 对应的原来节点
Node* cur = p[key];
int value = cur->value;
remove(cur); // 这里仅仅删除哈希双向链表中的节点,不必删除哈希表中的
// 将节点重现插入到缓冲区的头部
setHead(cur);
return value;
}
// 2.当该 key 值不存在
return -1;
}
// 将key-value值存入缓冲区
void put(int key, int value) {
// 1.当该 key 值存在
if(p.count(key) > 0)
{
// 删除该 key 对应的原来节点
Node* cur = p[key];
cur->value = value;
remove(cur); // 这里仅仅删除哈希双向链表中的节点,不必删除哈希表中的
// 将节点重现插入到缓冲区的头部
setHead(cur);
}
else// 2.当该 key 值不存在
{
Node* node = new Node(key, value);
// 判断当前缓冲区大小已经满了
if(p.size() >= size)
{
// 删除尾部节点
map<int, Node*>::iterator it = p.find(tail->key);// 返回迭代器类型
remove(tail);
p.erase(it);
setHead(node);
p[key] = node;// 这里erase 函数参数是迭代器类型,所以上面需要使用迭代器类型
// 将新节点插入到缓冲区的头部
}
else
//还没有满:将新节点插入到缓冲区的头部
{
setHead(node);
p[key] = node;
}
}
}
// 删除当前节点
void remove(Node* cur)
{
// 当前节点是 head
if(cur == head)
head = cur->next;
else if(cur == tail)// 当前节点是 tail
tail = cur->pre;
else// 当前节点是一般节点
{
cur->pre->next = cur->next;
cur->next->pre = cur->pre;
}
}
// 将当前节点插入到头部
void setHead(Node* cur)
{
cur->next = head;
if(head != nullptr)
head->pre = cur;
head = cur;//重现更新head
if(tail==nullptr)
tail = head;
}
};
疑问
为什么要是双向链表,单链表行不行?另外,既然哈希表中已经存了 key,为什么链表中还要存键值对呢,只存值不就行了?
对于问题1 删除链表的代码里我们能看出为什么
因为我们需要删除操作。删除一个节点不光要得到该节点本身的指针,也需要操作其前驱节点的指针,而双向链表才能支持直接查找前驱,保证操作的时间复杂度 O(1)。
对于问题2
当缓存容量已满,我们不仅仅要删除最后一个 Node 节点,还要把 map 中映射到该节点的 key 同时删除,而这个 key 只能由 Node 得到。如果 Node 结构中只存储 val,那么我们就无法得知 key 是什么,就无法删除 map 中的键,造成错误。