题目

你为最不经常使用（LFU）缓存算法设计并实现数据结构。

实现 LFUCache 类：

LFUCache(int capacity) - 用数据结构的容量 capacity 初始化对象 int get(int key) - 如果键存在于缓存中，则获取键的值，否则返回 -1。 void put(int key, int value) - 如果键已存在，则变更其值；如果键不存在，请插入键值对。当缓存达到其容量时，则应该在插入新项之前，使最不经常使用的项无效。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，应该去除最近最久未使用的键。注意「项的使用次数」就是自插入该项以来对其调用 get 和 put 函数的次数之和。使用次数会在对应项被移除后置为 0 。

为了确定最不常使用的键，可以为缓存中的每个键维护一个使用计数器。使用计数最小的键是最久未使用的键。

当一个键首次插入到缓存中时，它的使用计数器被设置为 1 (由于 put 操作)。对缓存中的键执行 get 或 put 操作，使用计数器的值将会递增。

来源：力扣（LeetCode）链接：leetcode-cn.com/problems/lf… 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

代码

class LFUCache {
    // 利用三个映射实现功能 key到值，key到freq,freq到对应的keys
    // freq到对应的keys:一对多、存在时序、可以 快速删除元素 LinkedHashSet
    HashMap<Integer,Integer> KeyToVal;
    HashMap<Integer,Integer> KeyToFreq;
    HashMap<Integer,LinkedHashSet> FreqToKeys;
    // 记录最小的频次，和最大容量
    int minFreq;
    int cap;
    public LFUCache(int capacity) {
        KeyToVal = new HashMap<>();
        KeyToFreq = new HashMap<>();
        FreqToKeys = new HashMap<>();
        this.cap = capacity;
        this.minFreq = 0;
    }
    // 获得key对应的值，无返回-1，有的话要增加访问频次，返回值
    public int get(int key) {
        if(!KeyToVal.containsKey(key)){
            return -1;
        }
        increaseFreq(key);
        return KeyToVal.get(key);
    }
    // 放入键对，如果已经存在，覆盖value并访问频次加一
    // 不存在：如果内存满了，要释放最小频次，再放入
    // 放入后三个映射都要更新
    public void put(int key, int value) {
        // 首先进行一下容量的判断，边界条件
        if (this.cap <= 0){
            return;
        }
        if(KeyToVal.containsKey(key)){
            KeyToVal.put(key, value);
            increaseFreq(key);
            return;
        }
        if (this.cap <= KeyToVal.size()){
            removeminFreq();
        }
        KeyToVal.put(key, value);
        // 第一次放入，频次freq为1
        KeyToFreq.put(key,1);
        // 因为频次和key是一对多的关系，要先看看这个频次是否有key
        // 很巧妙的使用了putIfAbsent，频次为1，为空的话就放入一个新的LinkedHashSet()
        FreqToKeys.putIfAbsent(1, new LinkedHashSet());
        // 向这个LinkedHashSet()中添加key
        FreqToKeys.get(1).add(key);
        // 每新加进来一个元素，minFreq重置为1
        this.minFreq = 1;

    }
    // 实现key的频次增加，首先先获取原本的频次，再向两个映射中更新
    //  FreqToKeys中更新是从freq中移到freq+1中，如果这是freq对应的映射刚好为空，则移除这个key
    // 如果此时freq == minFreq 则对 minFreq进行更新
    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);
        // FreqToKeys.get(freq+1).put(key);
        if (FreqToKeys.get(freq).isEmpty()){
            FreqToKeys.remove(freq);
            if(freq == minFreq){
                // ?为什么可以直接++，是因为key是从freq移到freq+1，所以是++
                minFreq++;
            }
        }
    }
    // 关于使用minFreq调值终于想明白了，就是不是1的话，就是1空了，往上移了所以minFreq++
    // 所以借助minFreq找到其对应的keylist进行删除操作
    // iterator().next() 找到keys里面的头结点，也就是最早加入的(最小频率可能对应多个key)
    public void removeminFreq(){
        // LinkedHashSet<Integer> keylist = FreqToKeys.get(minFreq);
        LinkedHashSet<Integer> keylist = FreqToKeys.get(this.minFreq);
        int delete = keylist.iterator().next();
        keylist.remove(delete);
        if (keylist.isEmpty()){
            FreqToKeys.remove(this.minFreq);
        }
        KeyToFreq.remove(delete);
        KeyToVal.remove(delete);
    }
}

【详细整理】460. LFU 缓存

题目

代码