当前位置：首页 > news >正文

leetcode_146 LRU缓存

news 2025/9/27 6:08:07

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);*/