LRU 缓存
力扣题目 146. LRU 缓存
实现 LRU 缓存需要用到哈希链表 LinkedHashMap。
LinkedHashMap 是由哈希表和双链表结合而成的，它的结构如下所示。
用自带的 LinkedHashMap 实现
利用 Java 语言自带的 LinkedHashMap 很容易实现 LRU 缓存。
class LRUCache {
// 缓存容量
int cap;
// 哈希链表
LinkedHashMap<Integer, Integer> cache = new LinkedHashMap<>();
// 初始化
public LRUCache(int capacity) {
this.cap = capacity;
}
public int get(int key) {
// 如果不存在这个 key, 返回 -1
if(!cache.containsKey(key)){
return -1;
}
// 存在这个 key
// 将该元素提升为最近使用过的
makeRecently(key);
return cache.get(key);
}
public void put(int key, int value) {
// 已经存在这个 key
if(cache.containsKey(key)){
// 修改 value 值
cache.put(key, value);
// 将该元素提升为最近使用过的
makeRecently(key);
return;
}
// 不存在这个 key
// 如果容量满了
if(cache.size() == cap){
// 删除链表头第一个元素（最不常使用的）
int oldKey = cache.keySet().iterator().next();
cache.remove(oldKey);
}
// 插入新元素
cache.put(key, value);
}
// 将该元素提升为最近使用过的
private void makeRecently(int key){
int value = cache.get(key);
// 删除该元素
cache.remove(key);
// 新增该元素
cache.put(key, value);
}
}
由于该题是面试高频考点，而面试官希望面试者能自己实现哈希链表，因此下面自己实现一下。
自己实现哈希链表
实现 MyLinkedHashMap
考虑写一个 MyLinkedHashMap 代替 LinkedHashMap。
下面是用 MyLinkedHashMap 代替 LinkedHashMap 的代码，为简化起见，不考虑泛型了，初始化就变成了 MyLinkedHashMap cache = new MyLinkedHashMap<>();
大部分 LinkedHashMap 的方法都保留了，将删除双链表的首元素封装成一个新方法 cache.removeEldest();
class LRUCache {
// 缓存容量
int cap;
// 哈希链表
MyLinkedHashMap cache = new MyLinkedHashMap();
public LRUCache(int capacity) {
this.cap = capacity;
}
public int get(int key) {
// 如果不存在这个 key, 返回 -1
if(!cache.containsKey(key)){
return -1;
}
// 存在这个 key
// 将该元素提升为最近使用过的
makeRecently(key);
return cache.get(key);
}
public void put(int key, int value) {
// 已经存在这个 key
if(cache.containsKey(key)){
// 修改 value 值
cache.put(key, value);
// 将该元素提升为最近使用过的
makeRecently(key);
return;
}
// 不存在这个 key
// 如果容量满了
if(cache.size() == cap){
// 删除链表头第一个元素（最不常使用的）
cache.removeEldest();
}
// 插入新元素
cache.put(key, value);
}
// 将该元素提升为最近使用过的
private void makeRecently(int key){
int value = cache.get(key);
// 删除该元素
cache.remove(key);
// 新增该元素
cache.put(key, value);
}
}
因此我们要实现 MyLinkedHashMap 的以下方法
class MyLinkedHashMap {
// 获取 key 对应的 value
public int get(int key) {}
// 新增一对 key, value 或修改 key 对应的 value
public void put(int key, int value) {}
// 删除 value 对应的元素
public void remove(int key) {}
// 删除链表首元素（也就是最近不被使用的元素）
public void removeEldest() {}
// 返回是否存在该 key
public boolean containsKey(int key) {}
// 返回当前容量
public int size() {}
}
MyLinkedHashMap 是有哈希表和双链表结合而成的，类中自然有这两个数据结构。
class MyLinkedHashMap {
// 哈希表
HashMap<Integer, Node> map = new HashMap<>();
// 双链表
DoubleList doubleList = new DoubleList();
}
下面一一实现上述方法
get 方法
由于 LRUCache 中调用 get 方法时已经考虑了 key 不存在的情况，调用 MyLinkedHashMap 中的 get 方法时 key 一定时存在的，因此就不用考虑 key 不存在的情况了。
// 获取 key 对应的 value
public int get(int key) {
return map.get(key).value;
}
put方法
由于 LRUCache 中调用 put 方法时可以新增，也可以修改，因此要在 MyLinkedHashMap 中的 put 方法考虑这两种情况
新增和删除要在哈希表和双链表中同时操作，保持一致性
// 新增一对 key, value 或修改 key 对应的 value
public void put(int key, int value) {
// 已经存在该 key, 修改
if(containsKey(key)) {
map.get(key).value = value;
return;
}
// 不存在该 key, 新增
Node node = new Node(key, value);
doubleList.addLast(node);
map.put(key, node);
}
remove 方法
// 删除 value 对应的元素
public void remove(int key) {
Node node = map.get(key);
doubleList.remove(node);
map.remove(key);
}
removeEldest 方法
这个方法也体现了为什么双链表中的节点应该同时保存 key 和 value ，因为需要删除双链表的首元素，还要删除 map 中对应的 key，因此要返回被删除的首元素节点，从首元素节点中获取 key。
// 删除链表首元素（也就是最近不被使用的元素）
public void removeEldest() {
Node node = doubleList.removeFirst();
map.remove(node.key);
}
containsKey 方法
直接调用 map 的 containsKey() 方法。
// 返回是否存在该 key
public boolean containsKey(int key) {
return map.containsKey(key);
}
size 方法
直接调用 map 的 size 方法。
// 返回当前容量
public int size() {
return map.size();
}
这样，MyLinkedHashMap 就写完了，该类的完整代码如下
class MyLinkedHashMap {
// 哈希表
HashMap<Integer, Node> map = new HashMap<>();
// 双链表
DoubleList doubleList = new DoubleList();
// 获取 key 对应的 value
public int get(int key) {
return map.get(key).value;
}
// 新增一对 key, value 或修改 key 对应的 value
public void put(int key, int value) {
// 已经存在该 key, 修改
if(containsKey(key)) {
map.get(key).value = value;
return;
}
// 不存在该 key, 新增
Node node = new Node(key, value);
doubleList.addLast(node);
map.put(key, node);
}
// 删除 value 对应的元素
public void remove(int key) {
Node node = map.get(key);
doubleList.remove(node);
map.remove(key);
}
// 删除链表首元素（也就是最近不被使用的元素）
public void removeEldest() {
Node node = doubleList.removeFirst();
map.remove(node.key);
}
// 返回是否存在该 key
public boolean containsKey(int key) {
return map.containsKey(key);
}
// 返回当前容量
public int size() {
return map.size();
}
}
实现双链表
由于 MyLinkedHashMap 中 map 是调用 java 现成的，而 DoubleList 不是 java 现成的，因此需要自己实现 DoubleList
DoubleList 的基本结构如下
class DoubleList {
// 虚拟头节点、虚拟尾节点
Node head, tail;
// 双链表长度
int size;
// 构造方法
public DoubleList() {
head = new Node(-1, -1);
tail = new Node(-1, -1);
head.next = tail;
tail.pre = head;
size = 0;
}
}
综合 MyLinkedHashMap 调用 DoubleList 的情况，需要实现 DoubleList 以下方法
class DoubleList {
// 在链表尾部新增一个元素
public void addLast(Node node) {}
// 从双链表中删除指定元素
public void remove(Node node) {}
// 删除首元素
public void removeFirst() {}
}
下面一一实现这些方法。
addLast 方法
在双链表尾部新增一个元素，要修改四个指针，注意顺序，防止指针丢失，先要修改不容易获得的节点的指针。
// 在链表尾部新增一个元素
public void addLast(Node node) {
node.pre = tail.pre;
node.next = tail;
tail.pre.next = node;
tail.pre = node;
size++;
}
remove 方法
从这个方法可以看出为什么选择双链表而不是单链表，因为需要在 O(1) 时间内删除任意位置的某个节点，删除一个节点需要它的前驱节点，单链表无法实现。
// 从双链表中删除指定元素
public Node remove(Node node) {
node.pre.next = node.next;
node.next.pre = node.pre;
size--;
}
removeFirst 方法
由于调用 removeFirst() 方法的只有 removeEldest() 方法，而 removeEldest() 方法被调用时 cache.size() == cap，而 cap 容量至少为1，因此双链表中是存在元素的，可以不用考虑双链表为空的情况。
// 删除首元素
public Node removeFirst() {
// 考虑双链表为空的情况
if(head.next == tail){
return null;
}
// 双链表不为空
// 获取双链表首元素
Node node = head.next;
remove(node);
return node;
}
因此 DoubleList 的完整代码如下
class DoubleList {
// 虚拟头节点、虚拟尾节点
Node head, tail;
// 双链表长度
int size;
// 构造方法
public DoubleList() {
head = new Node(-1, -1);
tail = new Node(-1, -1);
head.next = tail;
tail.pre = head;
size = 0;
}
// 在链表尾部新增一个元素
public void addLast(Node node) {
node.pre = tail.pre;
node.next = tail;
tail.pre.next = node;
tail.pre = node;
size++;
}
// 从双链表中删除指定元素
public void remove(Node node) {
node.pre.next = node.next;
node.next.pre = node.pre;
size--;
}
// 删除首元素
public Node removeFirst() {
// 考虑双链表为空的情况
if(head.next == tail){
return null;
}
// 双链表不为空
// 获取双链表首元素
Node node = head.next;
remove(node);
return node;
}
}
再补一下双链表的节点类
class Node {
// key, value
int key, value;
// 前驱节点, 后继节点
Node pre, next;
public Node() {}
public Node(int key, int value) {
this.key = key;
this.value = value;
}
}
自己实现的完整代码
最后，LRUcache 的完整代码如下
class LRUCache {
// 缓存容量
int cap;
// 哈希链表
MyLinkedHashMap cache = new MyLinkedHashMap();
public LRUCache(int capacity) {
this.cap = capacity;
}
public int get(int key) {
// 如果不存在这个 key, 返回 -1
if(!cache.containsKey(key)){
return -1;
}
// 存在这个 key
// 将该元素提升为最近使用过的
makeRecently(key);
return cache.get(key);
}
public void put(int key, int value) {
// 已经存在这个 key
if(cache.containsKey(key)){
// 修改 value 值
cache.put(key, value);
// 将该元素提升为最近使用过的
makeRecently(key);
return;
}
// 不存在这个 key
// 如果容量满了
if(cache.size() == cap){
// 删除链表头第一个元素（最不常使用的）
cache.removeEldest();
}
// 插入新元素
cache.put(key, value);
}
// 将该元素提升为最近使用过的
private void makeRecently(int key){
int value = cache.get(key);
// 删除该元素
cache.remove(key);
// 新增该元素
cache.put(key, value);
}
}
class MyLinkedHashMap {
// 哈希表
HashMap<Integer, Node> map = new HashMap<>();
// 双链表
DoubleList doubleList = new DoubleList();
// 获取 key 对应的 value
public int get(int key) {
return map.get(key).value;
}
// 新增一对 key, value 或修改 key 对应的 value
public void put(int key, int value) {
// 已经存在该 key, 修改
if(containsKey(key)) {
map.get(key).value = value;
return;
}
// 不存在该 key, 新增
Node node = new Node(key, value);
doubleList.addLast(node);
map.put(key, node);
}
// 删除 value 对应的元素
public void remove(int key) {
Node node = map.get(key);
doubleList.remove(node);
map.remove(key);
}
// 删除链表首元素（也就是最近不被使用的元素）
public void removeEldest() {
Node node = doubleList.removeFirst();
map.remove(node.key);
}
// 返回是否存在该 key
public boolean containsKey(int key) {
return map.containsKey(key);
}
// 返回当前容量
public int size() {
return map.size();
}
}
class DoubleList {
// 虚拟头节点、虚拟尾节点
Node head, tail;
// 双链表长度
int size;
// 构造方法
public DoubleList() {
head = new Node(-1, -1);
tail = new Node(-1, -1);
head.next = tail;
tail.pre = head;
size = 0;
}
// 在链表尾部新增一个元素
public void addLast(Node node) {
node.pre = tail.pre;
node.next = tail;
tail.pre.next = node;
tail.pre = node;
size++;
}
// 从双链表中删除指定元素
public void remove(Node node) {
node.pre.next = node.next;
node.next.pre = node.pre;
size--;
}
// 删除首元素
public Node removeFirst() {
// 考虑双链表为空的情况
if(head.next == tail){
return null;
}
// 双链表不为空
// 获取双链表首元素
Node node = head.next;
remove(node);
return node;
}
}
class Node {
// key, value
int key, value;
// 前驱节点, 后继节点
Node pre, next;
public Node() {}
public Node(int key, int value) {
this.key = key;
this.value = value;
}
}
总结
通过自己阅读别人的题解，再自己实现了几遍，写出了这篇题解，也是为了帮助自己更好的理解。然而在实现的过程中仍然出了一些bug，可想在面试的时候把上述代码无bug一次写出还是比较困难的。通过自己实现这道题，也理解了东哥所说的“算法就像搭乐高”，比如先用 MyLinkedHashMap 去实现 LRUcache，再去补 MyLinkedHashMap 中的方法实现，而 MyLinkedHashMap 中又用到 DoubleList 中的一些方法，用到了哪些方法再去补，这样对我来说比较容易记忆，以后只要会用自带的 LinkedHashMap 做，就能一步步改成自己实现的了，需要哪个就去造哪个。如果对整个流程用到哪些类都比较清晰，也可以先写 Node 类，再用 Node 类实现 DoubleList，再用DoubleList 类实现 MyLinkedHashMap ，最后用 MyLinkedHashMap 类实现 LRUcache，这不就像搭乐高了吗？
