问题描述
请你为 最不经常使用(LFU)缓存算法设计并实现数据结构。
实现 LFUCache 类:
• LFUCache(int capacity) - 用数据结构的容量 capacity 初始化对象
• int get(int key) - 如果键存在于缓存中,则获取键的值,否则返回 -1。
• void put(int key, int value) - 如果键已存在,则变更其值;如果键不存在,请插入键值对。当缓存达到其容量时,则应该在插入新项之前,使最不经常使用的项无效。在此问题中,当存在平局(即两个或更多个键具有相同使用频率)时,应该去除 最近最久未使用 的键。
注意「项的使用次数」就是自插入该项以来对其调用 get 和 put 函数的次数之和。使用次数会在对应项被移除后置为 0 。
为了确定最不常使用的键,可以为缓存中的每个键维护一个 使用计数器 。使用计数最小的键是最久未使用的键。
当一个键首次插入到缓存中时,它的使用计数器被设置为 1 (由于 put 操作)。对缓存中的键执行 get 或 put 操作,使用计数器的值将会递增。
解题方法
LinkedHashSet是Set集合的一个实现,具有set集合不重复的特点,同时具有可预测的迭代顺序,也就是我们插入的顺序
class LFUCache {
//存放key 和 value 的键值对
HashMap<Integer,Integer> keyToValue;
//存放key 和 freq(出现频次) 的键值对
HashMap<Integer,Integer> keyToFreq;
//存放feq 和 keys(key的LinkedHashSet集合) 的键值对
HashMap<Integer,LinkedHashSet<Integer>> freqToKeys;
int minFreq;
int capacity;
public LFUCache(int capacity) {
keyToValue = new HashMap<>();
keyToFreq = new HashMap<>();
this.capacity = capacity;
this.minFreq = 0;
}
public int get(int 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.minFreq = 1;
}
public void removeMinFreqKey(){
LinkedHashSet<Integer> keyList = freqToKeys.get(this.minFreq);
int deletedKey = keyList.iterator().next();
keyList.remove(deletedKey);
if(keyList.isEmpty()){
freqToKeys.remove(this.minFreq);
}
keyToValue.remove(deletedKey);
keyToFreq.remove(deletedKey);
}
public 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.minFreq){
this.minFreq++;
}
}
}
}