C++实现LFU缓存结构，leetcode 460

C++实现LFU缓存结构

解题思路

问题链接：https://leetcode.com/problems/lfu-cache/
LFU(Least Frequently Used)缓存，即最不经常使用页置换算法。在内存容量满的情况下，有新的数据进来，需要更多空间的时候，就需要删除被访问频率最少的元素。
get和put都要求O（1）的时间复杂度，用哈希表实现
代码如下

class LFUCache {
private:
	int cap; // 缓存容量
    int size; // 目前缓存的大小
    int minfre; //最小引用次数
    unordered_map<int, pair<int, int>> m; //key 与 {value, fre}之间的映射
    unordered_map<int, list<int>> hash_fre; //fre 与 list(以key为节点)之间的映射
    unordered_map<int, list<int>::iterator>  hash_node; // key与list节点之间的映射
public:
    LFUCache(int capacity) : cap(capacity) , size(0) {}
    
    int get(int key) {
        if(m.count(key) == 0) return -1;
        // get使fre+1，将原有的fre对应的list内结点删除，插入到fre+1对应的list中
        hash_fre[m[key].second].erase(hash_node[key]);
        m[key].second++;
        hash_fre[m[key].second].push_back(key);
        hash_node[key] = --hash_fre[m[key].second].end(); //更新hash_node[key]对应的节点
        if(hash_fre[minfre].size()==0){
            minfre++;
        }
        return m[key].first;
    }
    
    void put(int key, int value) {
        if(cap<=0) return;
        if(get(key) != -1) {
            m[key].first = value;
            return;
        }
        // 容量已满，删除最不常用的key
        if(size >= cap){
            m.erase(hash_fre[minfre].front());
            hash_node.erase(hash_fre[minfre].front());
            hash_fre[minfre].pop_front();
        }
        // 插入key
        m[key] = {value, 1};
        hash_fre[1].push_back(key);
        hash_node[key] = --hash_fre[1].end();
        minfre = 1;
        if(size < cap) size++;
    }
};