LRU,要做到 get 和 put 操作的 时间复杂度近似为 O(1)。我们可以想到使用 HashMap。HashMap 可以做到 get,put操作的近似 O(1),但是怎么记录哪个值是最近最久未使用过的呢?显然HashMap 无法做到。这时候,就想到了链表。链表的插入,删除操作是O(1)的,而且我们可以定义队头的元素是最近被使用的,队尾的元素是最近最少使用的。所以,经过分析,我们可以结合 HashMap 和 LinkedList 来实现。显然,链表使用双向链表更为方便。我们可以手写一个 DoubleLinkedLIst。
具体的代码:
class LRUCache {
// 这里定义,越靠近队头的元素,是最近被使用的。越靠近队尾的是最近最少使用的。
private DoubleLinkedList cache;
private Map<Integer, Node> map;
private int size;
public LRUCache(int capacity) {
cache = new DoubleLinkedList();
map = new HashMap<>();
size = capacity;
}
public int get(int key) {
if (!map.containsKey(key)) {
return -1;
}
// 缓存存在,注意这里要更新缓存到队头,代表最近被使用过
int value = map.get(key).value;
put(key, value);
return value;
}
public void put(int key, int value) {
Node newNode = new Node(key, value);
// 缓存原本不存在
if (!map.containsKey(key)) {
// 空间满了,要剔除最近最少使用的,也就是队尾的元素
if (map.size() == size) {
int k = cache.deleteAtTail();
map.remove(k);
}
cache.addAtHead(newNode);
map.put(key, newNode);
} else {
cache.delete(map.get(key));
cache.addAtHead(newNode);
map.put(key, newNode);
}
}
}
class DoubleLinkedList {
Node head;
Node tail;
public DoubleLinkedList() {
head = new Node(0, 0);
tail = new Node(0, 0);
head.next = tail;
tail.pre = head;
}
public void addAtHead(Node node) {
node.pre = head;
node.next = head.next;
head.next.pre = node;
head.next = node;
}
public int delete(Node node) {
int key = node.key;
node.pre.next = node.next;
node.next.pre = node.pre;
return key;
}
public int deleteAtTail() {
return delete(tail.pre);
}
}
class Node {
int key;
int value;
Node pre;
Node next;
public Node(int key, int value) {
this.key = key;
this.value = value;
}
}