LeetCode146. LRU缓存机制
运用你所掌握的数据结构,设计和实现一个LRU(最近最少使用) 缓存机制 。
实现LRUCache类:
- LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
- int get(int key) 如果关键字 key 存在于缓存中,则返回关键字的值,否则返回 -1 。
- void put(int key, int value) 如果关键字已经存在,则变更其数据值;如果关键字不存在,则插入该组「关键字-值」。当缓存容量达到上限时,它应该在写入新数据之前删除最久未使用的数据值,从而为新的数据值留出空间。
进阶:你是否可以在 O(1) 时间复杂度内完成这两种操作?
提示:
- 1 <= capacity <= 3000
- 0 <= key <= 10000
- 0 <= value <= 105
- 最多调用 2 * 105 次 get 和 put
分析:在本题中,每次get或put相应的键值对时,这个键值对就会更新自己的状态为最新状态。那么这个最新状态如何表示呢?使用链表即可,将表示这个键值对的节点移到开头(即根据key找到这个节点,然后将该节点移到开头,并将该节点左右节点相连)。但是对于普通的单向链表而言,这无法在O(1)的时间复杂度下实现。 所以使用双向链表实现将节点移到开头,以及将节点左右节点相连。使用哈希表实现key的O(1)查找。另外如何考虑容量呢?就是当哈希表的大小达到capacity时,将最后的节点删除即可
Java代码如下:
class LRUCache {
class Node {
int key,val;
Node l,r;
public Node(int key,int val) {
this.key = key;
this.val = val;
}
}
int n;
Node L,R;
Map<Integer,Node> map = new HashMap<>();
public LRUCache(int capacity) {
n = capacity;
L = new Node(-1,-1);
R = new Node(-1,-1);
L.r = R;
R.l = L;
}
public int get(int key) {
if(map.get(key) == null) {
return -1;
}
Node p = map.get(key);
delete(p);
insert(p);
return p.val;
}
public void put(int key, int value) {
if(map.get(key) == null) {
if(map.size() == n) {
Node p = R.l;
delete(p);
map.remove(p.key);
}
Node node = new Node(key,value);
insert(node);
map.put(key,node);
} else {
Node p = map.get(key);
delete(p);
Node node = new Node(key,value);
insert(node);
map.put(key,node);
}
}
public void delete(Node node) {
Node left = node.l,right = node.r;
left.r = right;
right.l = left;
}
public void insert(Node node) {
Node right = L.r;
node.l = L;
node.r = right;
L.r = node;
right.l = node;
}
}
/**
* 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);
*/