题目描述
请你为 最不经常使用（LFU）缓存算法设计并实现数据结构。它应该支持以下操作：get 和 put。
- get(key) - 如果键存在于缓存中，则获取键的值（总是正数），否则返回 -1。
- put(key, value) - 如果键已存在，则变更其值；如果键不存在，请插入键值对。当缓存达到其容量时，则应该在插入新项之前，使最不经常使用的项无效。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，应该去除最久未使用的键。
「项的使用次数」就是自插入该项以来对其调用 get 和 put 函数的次数之和。使用次数会在对应项被移除后置为 0 。
进阶：
你是否可以在 O(1) 时间复杂度内执行两项操作？
示例：
LFUCache cache = new LFUCache( 2 /* capacity (缓存容量) */ );
cache.put(1, 1);
cache.put(2, 2);
cache.get(1); // 返回 1
cache.put(3, 3); // 去除 key 2
cache.get(2); // 返回 -1 (未找到key 2)
cache.get(3); // 返回 3
cache.put(4, 4); // 去除 key 1
cache.get(1); // 返回 -1 (未找到 key 1)
cache.get(3); // 返回 3
cache.get(4); // 返回 4
题目链接： https://leetcode-cn.com/problems/lfu-cache/
思路
这题和LRU缓存机制很像。
LRU：
- 缓存满时，删除最久未使用的元素；
LFU：
- 缓存满时，删除使用频次最少的元素；
所以，在 LFU 中，我们还需要记录每个元素被访问的次数，每个元素除了 key，val 之外，还需要定义 freq 表示访问的次数：
struct Node{
int key;
int val;
int freq;
Node(int key, int val, int freq):key(key), val(val), freq(freq){}
};
我们使用两个哈希表：unordered_map<int, list<Node>::iterator> keyTable 用来存储 key 到链表节点指针的映射；unordered_map<int, list<Node>> freqTable 用来存储频数 freq 到链表的映射，具体如下图：
图来自这篇题解，左边的哈希表为 keyTable，右边的哈希表为 freqTale。可以看到 freqTable 根据频数存储了具体的链表，而 keyTable 存储了 key 到链表节点地址的映射。
除此之外，我们还需要一个变量 minFreq 来存储目前最少访问的次数，通过 freqTable[minFreq].pop_back() 删除使用最少的节点。
算法步骤：
-
get(key)：
- 如果 key 不在 keyTable 中，返回 -1；
- 否则，通过 keyTable[key] 获取 key 对应的节点地址 it，然后通过 it 得到节点的 key、val、freq，将节点从 freqTable[freq] 对应的链表删除，然后将该节点加入到 freqTable[freq+1] 对应的链表头；
-
put(key, value)：
- 如果 key 在 keyTable 中，则使用和 get(key) 中的第二步类似的方法；
- 否则，如果缓存已经满了，则根据 minFreq 删除使用最少的节点，然后设置 minFreq 为 1，将新的节点放入 freqTable[1] 对应的链表头。
具体代码如下：
struct Node{
int key;
int val;
int freq;
Node(int key, int val, int freq):key(key), val(val), freq(freq){}
};
class LFUCache {
private:
unordered_map<int, list<Node>::iterator> keyTable;
unordered_map<int, list<Node>> freqTable;
int capacity;
int minFreq;
public:
LFUCache(int capacity) {
this->capacity = capacity;
this->minFreq = 0;
}
int get(int key) {
if(keyTable.count(key)==0) return -1;
else{
auto it = keyTable[key]; // it 为 key 对应的节点地址
int val = it->val;
int freq = it->freq;
freqTable[freq].erase(it); // 在 freqTable[freq] 对应的链表中删除节点
if(freqTable[freq].size()==0){ // 如果删除后 freqTable[freq] 为空
freqTable.erase(freq);
if(minFreq==freq) minFreq++; // 注意这一步
}
freqTable[freq+1].push_front(Node(key, val, freq+1)); // 将节点放入 freqTable[freq+1] 对应的链表中
keyTable[key] = freqTable[freq+1].begin();
return val;
}
}
void put(int key, int value) {
if(this->capacity==0) return; // 注意判断容量是否为 0
if(keyTable.count(key)!=0){ // key 已经在缓存中了
auto it = keyTable[key]; // 下面的步骤和 get 函数中 else 部分基本相同
int freq = it->freq;
freqTable[freq].erase(it);
if(freqTable[freq].size()==0){
freqTable.erase(freq);
if(minFreq==freq) minFreq++;
}
freqTable[freq+1].push_front(Node(key, value, freq+1));
keyTable[key] = freqTable[freq+1].begin();
}
else{ // key 不在缓存中
if(keyTable.size()==this->capacity){ // 缓存容量已满
Node node = freqTable[minFreq].back(); // 通过 minFreq 找到使用最少的节点 back()
keyTable.erase(node.key); // 删除使用最少的节点
freqTable[minFreq].pop_back();
if(freqTable[minFreq].empty()){
freqTable.erase(minFreq);
}
}
freqTable[1].push_front(Node(key, value, 1));
keyTable[key] = freqTable[1].begin();
minFreq = 1; // minFreq 置为 1
}
}
};
/**
* Your LFUCache object will be instantiated and called as such:
* LFUCache* obj = new LFUCache(capacity);
* int param_1 = obj->get(key);
* obj->put(key,value);
*/
注意点：
- 在 freqTable[freq] 对应的链表中插入节点时，都是插入链表头 (push_front())；
- 每次在 freqTable[freq] 对应的链表中删除节点后，都要判断 freqTable[freq] 是否为空，如果为空，则将 freq 从 freqTable 中删除，并在必要的情况下更新 minFreq。
参考
1、https://leetcode-cn.com/problems/lfu-cache/solution/ha-xi-shuang-xiang-lian-biao-lfuhuan-cun-by-realzz/
2、https://leetcode-cn.com/problems/lfu-cache/solution/ha-xi-biao-shuang-xiang-lian-biao-java-by-liweiwei/