leetcode_146 LRU缓存 - 详解

1. 题意

请你设计并实现一个满足 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) 的平均时间复杂度运行。

2. 题解

单次插入需要$O(1)$，

查找也需要是$O(1)$。

因此我们需要哈希表和双向链表来完成这一操作。

2.1 我的解

直接自己写个双向链表。

同时我们需要维护链表头和尾。

需要注意的是一些异常情况，比如链表空，或者只有一个头节点。

class LRUCache {
public:
struct LRUNode {
LRUNode(int k, int v):key(k),value(v) {
}
int key;
int value;
};
struct LRUList {
LRUList *pre;
LRUList *next;
LRUNode *node;
};
LRUCache(int capacity):max_cap_(capacity){
}
int get(int key) {
// cout << "get " << key << "\n";
if ( hs.count(key) ) {
LRUList *cur = hs[key];
if ( cur != head) {
if ( cur == tail)
tail = cur->pre;
cur->pre->next = cur->next;
if (cur->next)
cur->next->pre = cur->pre;
head->pre  = cur;
cur->next = head;
cur->pre  = NULL;
head = cur;
}
return cur->node->value;
}
return -1;
}
void put(int key, int value) {
// cout << "put: [ " << key <<", " << value << " ]" << "\n"; 
if ( hs.count(key) ) {
LRUList *cur = hs[key];
cur->node->value = value;
if (cur == head)
return;
if ( cur == tail) {
tail = cur->pre;
}
cur->pre->next = cur->next;
if (cur->next)
cur->next->pre = cur->pre;
head->pre  = cur;
cur->next = head;
cur->pre  = NULL;
head = cur;
}
else {
LRUList *cur = new LRUList;
cur->pre = cur->next = NULL;
cur->node = new LRUNode(key, value);
++cur_cap_;
hs[key] = cur;
if (head)
head->pre = cur;
if (tail == NULL)
tail = cur;
cur->next = head;
head = cur;
if ( cur_cap_ > max_cap_) {
LRUList *del = tail;
// cout << "del " << del->node->key << "\n";hs.erase(del->node->key);tail = del->pre;if (tail)tail->next = NULL;del->pre = NULL;del->next = NULL;delete del->node;delete del;--cur_cap_;}}}private:int max_cap_;int cur_cap_{};unordered_map<int,LRUList *> hs;LRUList *head{};LRUList *tail{};};/*** Your LRUCache object will be instantiated and called as such:* LRUCache* obj = new LRUCache(capacity);* int param_1 = obj->get(key);* obj->put(key,value);*/

2.2 0x3f的解

我看0x3f的解，主要是模块化，还有加了一个哨兵节点就省去了首尾节点的判断。

class LRUCache {
public:
struct LRUNode {
LRUNode():pre(NULL),next(NULL) {
}
LRUNode(int key, int val):k(key),v(val), pre(NULL), next(NULL){
}
int k;
int v;
LRUNode *pre;
LRUNode *next;
};
private:
int cap_;
unordered_map<int, LRUNode *> key_to_node;LRUNode *dumNode;public:LRUCache(int capacity) : cap_(capacity), dumNode(new LRUNode()) {dumNode->pre = dumNode;dumNode->next = dumNode;}void remove(LRUNode *cur) {cur->pre->next = cur->next;cur->next->pre = cur->pre;cur->pre = cur->next = NULL;}void push_front(LRUNode *cur) {cur->next = dumNode->next;cur->pre  = dumNode;dumNode->next->pre =cur;dumNode->next = cur;}int get(int key) {//cout << "get " << key << "\n";auto it = key_to_node.find(key);if ( it != key_to_node.end()) {LRUNode *cur = it->second;remove( cur );push_front( cur );return cur->v;}return -1;}void put(int key, int value) {//cout << "put [ " << key << ", " << value << " ]\n";auto it = key_to_node.find(key);if ( it != key_to_node.end()) {LRUNode *cur  = it->second;cur->v = value;remove( cur );push_front( cur );}else {LRUNode *cur = new LRUNode(key, value);key_to_node[key] = cur;push_front(cur);if ( key_to_node.size() > cap_) {LRUNode *del_node = dumNode->pre;key_to_node.erase( del_node->k);remove( del_node);delete del_node;}}}};

还有一种就是使用标准库的双向链表了，不过标准库的api真的感觉好难用！

class LRUCache {
public:
struct LRUNode {
LRUNode(int k, int v):key(k),value(v) {
}
int key;
int value;
};
struct LRUList {
LRUList *pre;
LRUList *next;
LRUNode *node;
};
LRUCache(int capacity):max_cap_(capacity){
}
int get(int key) {
// cout << "get " << key << "\n";
auto it = key_to_it.find(key);
if ( it  == key_to_it.end()) {
return -1;
}
cached_list.splice( cached_list.begin(), cached_list, it->second);
return cached_list.begin()->value;
}
void put(int key, int value) {
auto it = key_to_it.find( key );
if ( it != key_to_it.end()) {
it->second->value = value;
cached_list.splice( cached_list.begin(), cached_list, it->second);
}
else {
auto nNode = new LRUNode(key, value);
cached_list.push_front( *nNode );
key_to_it[key] = cached_list.begin();
if ( cached_list.size() > max_cap_) {
key_to_it.erase(cached_list.back().key );
cached_list.pop_back();
}
}
}
private:
int max_cap_;
unordered_map<int, list<LRUNode>::iterator> key_to_it;list<LRUNode> cached_list;};/*** Your LRUCache object will be instantiated and called as such:* LRUCache* obj = new LRUCache(capacity);* int param_1 = obj->get(key);* obj->put(key,value);*/

3. 参考

0x3f

cpp-splice