LRU 缓存

已于 2022-08-22 10:03:04 修改
阅读量732 收藏
点赞数 1
分类专栏： Java 算法 文章标签： 缓存 java 算法
于 2022-08-22 10:00:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46283220/article/details/126458681
版权
算法 同时被 2 个专栏收录
83 篇文章 1 订阅
订阅专栏
Java
31 篇文章 1 订阅
订阅专栏

力扣题目 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，这不就像搭乐高了吗？

参考资料

算法就像搭乐高：带你手撸 LRU 算法

dotJunz
关注
专栏目录
LRU缓存（LRUCache）
爱写bug的王六六
02-27 5441
146. LRU 缓存 题目描述： 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类： LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存（cache） int get(int key)如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ； 如果不存在，则向缓存
LRU缓存
weixin_43624024的博客
10-16 2943
一、什么是LRU算法 LRU，Least Recently Used算法，即一种缓存淘汰策略。 计算机的缓存容量有限，若缓存满了则需要删除一些内容，给新的缓存腾出空间，但问题是要删除哪些内容呢？当然是把用的少的缓存删掉，把最有用的数据继续保留以便于继续使用。那么如何判定哪些数据是有用的呢？ 缓存淘汰的策略有很多，而LRU则是一种较为简单常用的算法，LRU判定最近使用过的数据为有用的，很久都没...
数据结构-LRU缓存（C语言实现）
最新发布
pyc68的博客
10-01 1029
本篇文章主要是为了记录实现LRU缓存的方法和思考的过程。
【数据结构】LRU缓存
2301_76762420的博客
04-21 968
LRU缓存是一种基于双向链表和哈希表的数据结构，用于管理缓存中的数据并自动淘汰最近最少使用的数据。它通过高效的插入、访问和删除操作，提高了应用程序的性能。LRU缓存非常适合用于对数据访问频率较高且具有较强时效性的数据集。
LRU 缓存实现
厚积薄发的博客
02-12 619
LRU缓存的设计思想: 在有限的空间下,如何访问和更新其中的元素. LRU缓存的设计原则: 如果一个数据在一段时间内没有被访问,以后这个数据被访问到的可能性也非常小,当访问的空间满时,删除最久的没有访问过的数据. 使用hashmap加双向链表 import sun.applet.Main; import java.util.HashMap; import java.util.Map; ...
LRU缓存-LRU缓存的C ++实现-C/C++开发
05-27
快速的，仅标头的通用C ++ 17 LRU缓存库，带有可自定义的后端。 LRU缓存一种快速的，仅标头的通用C ++ 17 LRU缓存库，带有可自定义的后端。 用法示例缓存对昂贵函数的调用#include“ lru_cache / lru_cache.h” int ...
详解Java实现LRU缓存
08-18
Java 实现 LRU 缓存 LRU 缓存是指 Least Recently Used 缓存，翻译过来就是“最近最少使用”，它是一种常用的缓存策略。 Java 实现 LRU 缓存有多种方法，本文将介绍使用 LinkedHashMap 实现 LRU 缓存的方法。 LRU ...
Java实现LRU缓存的实例详解
08-29
Java实现LRU缓存的实例详解 Java实现LRU缓存的实例详解是指通过Java语言实现一种高效的缓存机制，即LRU（Least Recently Used）缓存。LRU缓存是一种常用的缓存策略，其主要思想是将最近使用的数据存储在缓存中，...
Java实现简单LRU缓存机制的方法
08-19
Java实现简单LRU缓存机制的方法 Java实现简单LRU缓存机制的方法是指通过Java语言实现的一种缓存机制，该机制可以根据最近最少使用的原则淘汰缓存中的数据。缓存机制的实现主要是通过哈希表和双向链表来实现的。 ...
Java实现简单LRU缓存算法
05-20
这里的LRUCache类维护了一个双向链表和一个哈希表，用于实现LRU算法。具体实现细节如下： - get方法：首先在哈希表中查找对应的键值对，如果不存在，则返回-1；如果存在，则将对应的节点从双向链表中删除，并将其...
LRU缓存机制，你想知道的这里都有
q1472750149的博客
12-27 894
概述 LRU是Least Recently Used的缩写，译为最近最少使用。它的理论基础为 “最近使用的数据会在未来一段时期内仍然被使用，已经很久没有使用的数据大概率在未来很长一段时间仍然不会被使用” 由于该思想非常契合业务场景 ，并且可以解决很多实际开发中的问题，所以我们经常通过LRU的思想来作缓存，一般也将其称为LRU缓存机制。 原理 实现LRU时，我们需要关注它的读性能和写性能，理想的LRU应该可以在O(1)的时间内读取一条数据或更新一条数据，也就是说读写的时间复杂度都是O(1)。 此时很容
leetcode LRU 缓存
weixin_38184628的博客
06-15 689
所以需要使用链表来表示缓存，当访问一个数据的时候需要将当前这个数据从原来的位置上删除，然后加到链表的头部，删除一个节点的话，需要将这个节点的前一个节点和下一个节点连接起来，如果使用单向链表的话，那么只能找到这个节点的下一个节点，找不到上一个节点，所以需要使用双向链表。（6）向缓存中放入数据 1，此时缓存是满的，所以需要先淘汰一个数据，从访问时间来看，最后一次访问 50 的间隔时间最长，也就是排在最右边的数据，所以将 50 淘汰，其它数据向后移动，将新数据 1 放入最左边的位置。
LeetCode 146：LRU 缓存
机械工程跑路哥
07-20 1028
因为在删除节点时，使用removeFirst()删除链表头部也就是最长时间未使用的节点，然后需要再根据该方法返回的这个节点的key，去删除hashmap中对应的键值对；而事实上，在一个时间段内，只需要访问一小部分数据即可正常运行，这就导致内存中驻留了大量用不到的数据；因为删除链表时，双向链表的前驱操作可以保证时间复杂度为O(1)，而单向链表的删除要从头遍历直到找到节点，时间复杂度为O(n)；LRU的全称是LeastRecentlyUsed，也就是说我们认为最近使用过的数据应该是是「有用的」，........
数据结构设计之LRU缓存
weixin_41804570的博客
06-29 355
 146. LRU 缓存【中等】，链接: linkJava
LRU缓存机制
技术分享博客
09-07 1188
计算机的缓存容量有限，如果缓存满了就要删除一些内容，给新内容腾位置。那么，什么样的数据，我们判定为「有用的」的数据呢？LRU 的全称是 Least Recently Used，也就是说我们认为最近使用过的数据应该是「有用的」，很久都没用过的数据应该是无用的，内存满了就优先删那些很久没用过的数据。常见的场景如手机的后台运行缓存，我们依次打开了[王者荣耀] [淘宝] [微信] [抖音]，假设手机只允许同时打开个应用程序，那么在我们打开抖音的那一刻，就会将最久未使用的 [王者荣耀] 关闭，腾出空间给 抖音。
本地缓存与LRU
weixin_30514745的博客
07-20 289
　　LRU这是一种内存淘汰算法，实际上解释它也挺简单的，分为两个维度：1.容量；2.时间。 　　我们有一个有界队列，如果不断地往其中写入数据，总会满的，这个时候需要对数据进行淘汰。如果超过了容量，在插入数据的时候应该淘汰哪些数据。那就是不经常用的，冷数据。LRU的主旨是保存最近经常使用的数据，经常使用的数据叫做热点数据，保留它们的价值在于：它们经常被访问，从缓存中取就不用去频繁访问数据...
深入解析LRU缓存算法原理与实现
例如，在C++中，可以使用标准库中的list或unordered_map来辅助实现LRU缓存。需要注意的是，当链表头部发生插入操作时，需要先在链表中查找是否存在待插入数据，以保证缓存的命中率。 8. LRU算法的测试与优化：对于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

dotJunz

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值