LRU缓存机制
LRU实现代码
LRU
Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。
实现
哈希表 + 双向链表
用一个哈希表和一个双向链表维护所有在缓存中的键值对。
双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的。
这样以来，我们首先使用哈希表进行定位，找出缓存项在双向链表中的位置，随后将其移动到双向链表的头部，即可在 O(1)的时间内完成 get 或者 put 操作。
上述各项操作中，访问哈希表的时间复杂度为 O(1)，在双向链表的头部添加节点、在双向链表的尾部删除节点的复杂度也为 O(1)。而将一个节点移到双向链表的头部，可以分成「删除该节点」和「在双向链表的头部添加节点」两步操作，都可以在 O(1)时间内完成。
注意
在双向链表的实现中，使用一个伪头部（dummy head）和伪尾部（dummy tail）标记界限，这样在添加节点和删除节点的时候就不需要检查相邻的节点是否存在。
代码
#include<unordered_map>
struct DlistNode{
int key, value;
DlistNode* prev;
DlistNode* next;
DlistNode():key(0),value(0),prev(nullptr),next(nullptr){}
DlistNode(int _key,int _value):key(_key),value(_value),prev(nullptr),next(nullptr){}
};
class LRUCache {
private:
int cap;
int size;
unordered_map<int,DlistNode*> cache;
DlistNode* head = nullptr;
DlistNode* tail = nullptr;
public:
LRUCache(int capacity):size(0),cap(capacity) {
head = new DlistNode();
tail = new DlistNode();
head->next = tail;
tail->prev = head;
}
int get(int key) {
if(!cache.count(key)){
return -1; //如果 key 不存在，则返回 -1
}else{
movetohead(cache[key]); //key 存在，通过哈希表定位到该节点在双向链表中的位置，并将其移动到双向链表的头部，返回该节点的值
return cache[key]->value;
}
}
void put(int key, int value) {
if(!cache.count(key)){
//如果 key 不存在，使用 key 和 value 创建一个新的节点，在双向链表的头部添加该节点，并将 key 和该节点添加进哈希表中。然后判断双向链表的节点数是否超出容量
DlistNode* node = new DlistNode(key,value);
cache[key] = node;
addtohead(node);
if(size > cap){ //如果超出容量，则删除双向链表的尾部节点，并删除哈希表中对应的项
DlistNode* node = tail->prev;
remove(node);
cache.erase(node->key);
delete node;
node = nullptr;
}
}else{
cache[key]->value = value; //如果 key 存在，则与 get 操作类似，先通过哈希表定位，再将对应的节点的值更新为 value，并将该节点移到双向链表的头部。
movetohead(cache[key]);
}
}
void remove(DlistNode* node){
node->prev->next = node->next;
node->next->prev = node->prev;
--size;
return;
}
void addtohead(DlistNode* node){
head->next->prev = node;
node->next = head->next;
head->next = node;
node->prev = head;
++size;
return;
}
void movetohead(DlistNode* node){
remove(node);
addtohead(node);
return;
}
};
