题目描述
LRU缓存
请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。
实现 LRUCache 类:
- LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
- int get(int key) 如果关键字 key 存在于缓存中,则返回关键字的值,否则返回 -1 。
- void put(int key, int value) 如果关键字 key 已经存在,则变更其数据值 value ;如果不存在,则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ,则应该 逐出 最久未使用的关键字。
函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。
示例:
输入
[“LRUCache”, “put”, “put”, “get”, “put”, “get”, “put”, “get”, “get”, “get”]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]
解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1); // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废,缓存是 {1=1, 3=3}
lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废,缓存是 {4=4, 3=3}
lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
lRUCache.get(4); // 返回 4
各种解法
原始解法:双向链表+哈希表
// 双向链表的Node,既含有key,又含有value
class Node{
public int key, val;
public Node next, prev;
public Node(int k, int v){
this.key = k;
this.val = v;
}
}
// 双向链表
class DoubleList{
private Node head, tail;
private int size;
public DoubleList(){
// 虚拟节点
head = new Node(0,0);
tail = new Node(0,0);
head.next = tail;
tail.prev = head;
size = 0;
}
// 最后的是新添加的
public void addLast(Node x){
x.prev = tail.prev;
x.next = tail;
tail.prev.next = x;
tail.prev = x;
size++;
}
// 删除特定节点
public void remove(Node x){
x.prev.next = x.next;
x.next.prev = x.prev;
size--;
}
// 删除第一个节点
public Node removeFirst(){
if(head.next == tail){
return null;
}
Node first = head.next;
remove(first);
return first;
}
public int size(){
return size;
}
}
public class LRUCache {
private HashMap<Integer, Node> map;
private DoubleList cache;
private int cap;
public LRUCache(int capacity){
this.cap = capacity;
map = new HashMap<>();
cache = new DoubleList();
}
// 获取key的值,并且因为对该key有操作,要使之最近使用,O(1)
public int get(int key){
if(!map.containsKey(key)){
return -1;
}
makeRecently(key);
return map.get(key).val;
}
// 添加一个节点
// 如果已经存在,删除节点,添加并且使之最近使用
// 如果容量已经最大,把最近最少使用的删除
public void put(int key, int val){
if(map.containsKey(key)){
deleteKey(key);
addRencently(key,val);
return;
}
if(cap == cache.size()){
removeLeastRecently();
}
addRencently(key,val);
}
// 使得该key最近,最后的是最近的
private void makeRecently(int key){
Node x = map.get(key);
cache.remove(x);
cache.addLast(x);
map.put(key,x);
}
// 如果之前没有,就直接添加到最后
private void addRencently(int key, int val){
Node x = new Node(key, val);
cache.addLast(x);
map.put(key,x);
}
// 删除该key
private void deleteKey(int key){
Node x = map.get(key);
cache.remove(x);
map.remove(key);
}
// 删除最近最少使用的,也就是头结点,容量限制,先删它
private void removeLeastRecently(){
Node deleteNode = cache.removeFirst();
int deleteKey = deleteNode.key;
map.remove(deleteKey);
}
}
解题思路:LRU逻辑
- 添加元素:
- key已有,改变该key的value,放到最近(链表最后)
- 新的key
- 未满,添加到最近
- 满了,删除最近最少使用的(链表最开头),新key添加到最后
- 获取元素:获取,然后把节点放到最近
- 删除元素:删除最近最少使用的 或者 删除特定的
2个问题
- 为什么使用双向链表,单链表行不行?
答: 删除中间的节点的时候,需要将 pre 和 next 相连,单链表还得去找他的 pre ,不可能O(1) - 哈希表中已经存了key,为什么链表中还要存键值对,只存值不行吗?
答: 双向链表可以保持次序,hashmap可以做到快速查找。所以在删除不常使用的元素时,是删除双向链表中的元素,与此同时需要更新hashmap。更新的方式,就是通过被删除节点的key来找到hashmap中的key,从而删除hashmap中的键。所以双向链表中的节点不仅仅需要值,还需要键对应到hashmap上的键。
双向哈希链表LinkedHashMap
双向哈希链表是一种天然的双向链表+哈希表的集合类。元素的次序是保持插入的顺序。
class LRUCache {
int cap;
LinkedHashMap<Integer, Integer> cache = new LinkedHashMap<>();
public LRUCache(int capacity) {
this.cap = capacity;
}
public int get(int key) {
if (!cache.containsKey(key)) {
return -1;
}
// 将 key 变为最近使用
makeRecently(key);
return cache.get(key);
}
public void put(int key, int val) {
if (cache.containsKey(key)) {
// 修改 key 的值
cache.put(key, val);
// 将 key 变为最近使用
makeRecently(key);
return;
}
if (cache.size() >= this.cap) {
// 链表头部就是最久未使用的 key
int oldestKey = cache.keySet().iterator().next();
cache.remove(oldestKey);
}
// 将新的 key 添加链表尾部
cache.put(key, val);
}
private void makeRecently(int key) {
int val = cache.get(key);
// 删除 key,重新插入到队尾
cache.remove(key);
cache.put(key, val);
}
}
变形题及其解法
1. LFU缓存实现
LRU是最近最少使用,LFU是最不常用(按照使用频率排序)
class LFUCache {
// 维护kv表,kf表,fk表
// 键和值,键和频率,频率和键 共3张表
// 设置容量和需要删除的最小频率
public int capacity; //容量
public int mincapacity;
public HashMap<Integer, Integer> keyToValue;
public HashMap<Integer, Integer> keyToFreq;
public HashMap<Integer, LinkedHashSet<Integer>> freqToKeys;
public LFUCache(int capacity) {
this.capacity = capacity;
mincapacity = 0;
keyToValue = new HashMap<>();
keyToFreq = new HashMap<>();
freqToKeys = new HashMap<>();
}
// 获取元素
public int get(int key) {
// 要获取某个key,对应的三张表应该进行更新
if(!keyToValue.containsKey(key)){
return -1;
}
increaseFreq(key);
return keyToValue.get(key);
}
// 添加元素
public void put(int key, int value) {
if(this.capacity<=0) return;
if(keyToValue.containsKey(key)){
keyToValue.put(key,value);
increaseFreq(key);
return;
}
if(this.capacity<=keyToValue.size()){
removeMinFreqKey();
}
// 更新各张表
keyToValue.put(key,value);
keyToFreq.put(key,1);
// 如果没有该频率则添加
freqToKeys.putIfAbsent(1,new LinkedHashSet<>());
freqToKeys.get(1).add(key);
this.mincapacity = 1;
}
private void increaseFreq(int key){
int freq = keyToFreq.get(key);
keyToFreq.put(key,freq+1);
freqToKeys.get(freq).remove(key);
freqToKeys.putIfAbsent(freq+1,new LinkedHashSet<>());
freqToKeys.get(freq+1).add(key);
if(freqToKeys.get(freq).isEmpty()){
freqToKeys.remove(freq);
if(freq==this.mincapacity){
this.mincapacity++;
}
}
}
private void removeMinFreqKey(){
LinkedHashSet<Integer> keyList = freqToKeys.get(this.mincapacity);
int deleteKey = keyList.iterator().next();
keyList.remove(deleteKey);
if(keyList.isEmpty()){
freqToKeys.remove(this.mincapacity);
}
keyToValue.remove(deleteKey);
keyToFreq.remove(deleteKey);
}
}
解题思路:LFU逻辑
- 添加元素
- 如果元素已经存在,添加新值,使用频率+1
- 如果元素不存在
- 容量已满,删除频率最小的键
- 容量未满,更新3张表
- 获取元素
- 元素不存在,返回-1
- 元素存在,该元素的keyToFreq的频率+1
- 删除元素
- 删除元素,更新3张表