一.题目要求
请你设计并实现一个满足 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
提示:
1 <= capacity <= 3000
0 <= key <= 10000
0 0 0 <= value <= 1 0 5 10^5 105
最多调用 2 ∗ 1 0 5 2 * 10^5 2∗105 次 get 和 put
四.解题思路
哈希表 + 双向链表
哈希表对于key,结点地址的映射解决了链表查找时间复杂度的问题,从 o ( n ) o(n) o(n)降成了 o ( 1 ) o(1) o(1)。
官方做法:
五.代码实现
cpp
struct DListNode {
int key;
int value;
DListNode* prev;
DListNode* next;
DListNode() :key(-1),value(0),prev(nullptr),next(nullptr) {}
DListNode(int _key, int _value):key(_key),value(_value),prev(nullptr),next(nullptr){}
};
class LRUCache {
public:
LRUCache(int capacity) {
cacheSize = capacity;
DListSize = 0;
head = new DListNode();
tail = new DListNode();
head->next = tail;
tail->prev = head;
}
int get(int key) {
//如果有这个值,把该值对应结点移到头部
if (cacheMap.count(key))
{
DListNode* node = cacheMap[key];
removeToHead(node);
return node->value;
}
else return -1;
}
void put(int key, int value) {
//如果有这个值,修改该值对应的value,移到头部
if (cacheMap.count(key))
{
//修改
cacheMap[key]->value = value;
//移到头部
DListNode* node = cacheMap[key];
removeToHead(node);
}
else
{
//如果当前结点数未达到上限,则插入到队尾,DSIZE++
if (DListSize < cacheSize)
{
DListNode* node = new DListNode(key, value);
cacheMap.insert(make_pair(key, node));
addToHead(node);
DListSize++;
}
//达到上限,则移除队首元素及其哈希表,插入新元素到队尾
else
{
DListNode* node = new DListNode(key, value);
cacheMap.insert(make_pair(key, node));
cacheMap.erase(tail->prev->key);
addToHead(node);
deleteTail();
}
}
}
void removeToHead(DListNode* key)
{
key->prev->next = key->next;
key->next->prev = key->prev;
addToHead(key);
}
void addToHead(DListNode* key)
{
key->next = head->next;
key->prev = head;
head->next = key;
key->next->prev = key;
}
void deleteTail()
{
DListNode* delNode = tail->prev;
tail->prev->prev->next = tail;
tail->prev = tail->prev->prev;
delete delNode;
}
private:
int cacheSize;
DListNode* head;
DListNode* tail;
unordered_map<int, DListNode*> cacheMap;
int DListSize;
};
/**
* 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);
*/
六.题目总结
手撕Java的LinkedHashMap。。