题目描述:设计和实现一个 LRU (最近最少使用) 缓存机制
实现 LRUCache 类:
LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存;
int get(int key) 如果关键字 key 存在于缓存中,则返回关键字的值,否则返回 -1 ;
void put(int key, int value) 如果关键字已经存在,则变更其数据值;如果关键字不存在,则插入该组「关键字-值」。当缓存容量达到上限时,它应该在写入新数据之前删除最久未使用的数据值,从而为新的数据值留出空间。
在 O(1)
时间复杂度内完成这两种操作
解题思路:双向链表+哈希表
public class LRUCache {
class CacheNode {
int key;
int value;
CacheNode pre;
CacheNode next;
public CacheNode() {
}
public CacheNode(int key, int value) {
this.key = key;
this.value = value;
}
}
private int capacity;
private int size;
private Map<Integer, CacheNode> cache = new HashMap<>();
private CacheNode head, tail;
public LRUCache(int capacity) {
this.capacity = capacity;
this.size = 0;
head = new CacheNode();
tail = new CacheNode();
head.next = tail;
tail.pre = tail;
}
public int get(int key) {
CacheNode node = this.cache.get(key);
if (node == null) {
return -1;
}
// 访问过移到最前面
moveToHead(node);
return node.value;
}
public void put(int key, int value) {
CacheNode node = this.cache.get(key);
if (node == null) {
// 不存在 创建新节点
CacheNode newNode = new CacheNode(key, value);
this.cache.put(key, newNode);
addToHead(newNode);
if (this.size == this.capacity) {
CacheNode nodeTail = removeTail();
this.cache.remove(nodeTail.key);
}else {
this.size++;
}
} else {
//存在就更新
node.value = value;
// 移到头部
moveToHead(node);
}
}
private void moveToHead(CacheNode node) {
removeNode(node);
addToHead(node);
}
private void addToHead(CacheNode node) {
node.pre = this.head;
node.next = this.head.next;
this.head.next.pre = node;
this.head.next = node;
}
private void removeNode(CacheNode node) {
node.pre.next = node.next;
node.next.pre = node.pre;
}
private CacheNode removeTail() {
CacheNode node = tail.pre;
removeNode(node);
return node;
}
}