lfu java_LFU - 猫熊小才天 - 博客园

date: 2020-12-08 10:49:21

updated: 2020-12-08 14:57:09

LFU

LFU(Least Frequently Used ，最近最少使用算法)

算法描述：

class LFUCache {

// 构造容量为 capacity 的缓存

public LFUCache(int capacity) {}

// 在缓存中查询 key

public int get(int key) {}

// 将 key 和 val 存入缓存

public void put(int key, int val) {}

}

get(key)方法会去缓存中查询键key，如果key存在，则返回key对应的val，否则返回 -1。

put(key, value)方法插入或修改缓存。如果key已存在，则将它对应的值改为val；如果key不存在，则插入键值对(key, val)。

当缓存达到容量capacity时，则应该在插入新的键值对之前，删除使用频次(后文用freq表示)最低的键值对。如果freq最低的键值对有多个，则删除其中最旧的那个。

思路：

需要有一个HashMap来保存key到val的映射，用来计算 get(key)

HashMap keyToVal;

需要有一个HashMap来保存key到freq的映射，用来计算每一个key的频次

HashMap keyToFreq;

算法的核心需求(思路)

需要freq到key的映射，用来找到最小freq对应的key

如果要满足上一条，快速找到最小freq是多少，可以通过一个变量minFreq来记录当前最小freq，避免遍历

可能会有多个key拥有相同的freq，所以freq和key是一对多的关系，那么就需要维护一个freq到key对应的映射关系

为了保证快速查找并删除最旧的key，就需要保证freq对应的key的映射列表应该是有顺序的

需要能够快速删除key列表中的任何一个key。如果频次为freq的key被访问了，它的频次应该变成freq+1，此时应该从freq对应的key列表中删除，并把key加入到freq+1对应的key列表中 => 就是需要提高它的频次

HashMap> freqToKeys;

int minFreq;

如果用 LinkedList 可以满足第3、4条，但是链表不能快速访问某一个节点，所以不能满足第5条快速删除

综上，LFUCache 类代码如下：

class LFUCache {

// key 到 val 的映射，我们后文称为 KV 表

HashMap keyToVal;

// key 到 freq 的映射，我们后文称为 KF 表

HashMap keyToFreq;

// freq 到 key 列表的映射，我们后文称为 FK 表

HashMap> freqToKeys;

// 记录最小的频次

int minFreq;

// 记录 LFU 缓存的最大容量

int cap;

public LFUCache(int capacity) {

keyToVal = new HashMap<>();

keyToFreq = new HashMap<>();

freqToKeys = new HashMap<>();

this.cap = capacity;

this.minFreq = 0;

}

public int get(int key) {

if (!keyToVal.containsKey(key))

return -1;

// 增加key对应的频次

increaseFreq(key);

return keyToVal.get(key);

}

public void put(int key, int val) {

// 避免初始化的时候capacity参数异常

if (this.cap <= 0)

return;

// 如果 KV 表已经存在这个key

// 修改对应的val，频次+1

if (keyToVal.containsKey(key)) {

keyToVal.put(key, val);

increaseFreq(key);

return;

}

// 如果 KV 表不存在这个key

// 并且当前容量已满，就需要删除最小频次的key

if (keyToVal.size() >= this.cap) {

removeMinFreqKey();

}

// 当前容量未满，插入key和val，并且key对应的freq置为1

keyToVal.put(key, val);

keyToFreq.put(key, 1);

// putIfAbsent 如果有这个key的话就不进行任何操作，此处相当于对1这个key进行初始化

freqToKeys.putIfAbsent(1, new LinkedHashSet<>());

freqToKeys.get(1).add(key);

// 插入最新的key之后，最小的freq肯定是1

this.minFreq = 1;

}

private void increaseFreq(int key) {

// 首先，能进入到这个函数的时候，keyToFreq 和 freqToKeys 一定保存过这个key了

// 更新 KF 表中key对应的频次+1

int freq = keyToFreq.get(key);

keyToFreq.put(key, freq + 1);

// Fk 表中删除freq对应的列表中的key

freqToKeys.get(freq).remove(key);

freqToKeys.putIfAbsent(freq + 1, new LinkedHashSet<>());

freqToKeys.get(freq + 1).add(key);

// 如果 freq 对应的列表空了，就移除这个freq

if (freqToKeys.get(freq).size() == 0) {

freqToKeys.remove(freq);

// 如果这个 freq 又恰好是 minFreq，更新 minFreq

// 这个地方容易忘记更新

if (freq == this.minFreq) {

this.minFreq++;

}

}

}

private void removeMinFreqKey() {

// FK 表中最小freq对应的列表中 最先被插入的那个 key 就是该被淘汰的 key

LinkedHashSet keyList = freqToKeys.get(this.minFreq);

int deleteKey = keyList.iterator().next();

keyList.remove(deleteKey);

// 如果 freq 对应的列表空了，就移除这个freq

if(keyList.size() == 0){

freqToKeys.remove(this.minFreq);

// 这里不需要更新 minFreq，因为后面会紧跟一个put操作，minFreq 会被置为1

}

// 更新 KV 表

keyToVal.remove(deleteKey);

// 更新 KF 表

keyToFreq.remove(deleteKey);

}

}