面试常客之手写LFU缓存机制

LFU比LRU的实现更复杂，代码量更大。

有两种方式，一是自己实现哈希链表这种数据结构，然后再解答。

另一种是使用Java的HashMap和LinkedHashSet来实现，直接使用内置数据结构来解答。

直接上代码吧，注释的很清楚了。

第一种：自己实现哈希链表这种数据结构

class LFUCache {
    
    //存储key，value，freq
    Map<Integer, Node> keyTable;
    //存储freq和双链表
    Map<Integer, DoubleList> freqTable;
    //记录最少使用
    int minfreq;
    //缓存容量
    int capacity;

    public LFUCache(int capacity) {
        keyTable = new HashMap<>();
        freqTable = new HashMap<>();
        this.minfreq = 0;
        this.capacity = capacity;
    }
    
    //查询元素
    public int get(int key) {
        if (capacity == 0) {
            return -1;
        }
        if (!keyTable.containsKey(key)) {
            return -1;
        }

        //增加key的freq
        increaseFreq(key);

        return keyTable.get(key).val;
    }
    
    //添加元素
    public void put(int key, int value) {
        if (capacity == 0) {
            return;
        }

        //如果key已经存在，修改对应的value即可
        if (keyTable.containsKey(key)) {
            // 与 get 操作基本一致，除了需要更新缓存的值
            Node node = keyTable.get(key);
            int freq = node.freq;
            freqTable.get(freq).remove(node);
            if (freqTable.get(freq).size() == 0) {
                freqTable.remove(freq);
                if (minfreq == freq) {
                    minfreq++;
                }
            }
            DoubleList list = freqTable.getOrDefault(freq + 1, new DoubleList());
            list.addFirst(new Node(key, value, freq + 1));
            freqTable.put(freq + 1, list);
            keyTable.put(key, freqTable.get(freq + 1).getHead());
            return;
        }

        //如果key不存在，插入新数据

        //如果缓存容量满了，删除最久最少未使用的元素
        if (keyTable.size() == capacity) {
            removeMinFreqKey();
        }

        DoubleList list = freqTable.getOrDefault(1, new DoubleList());
        list.addFirst(new Node(key, value, 1));
        freqTable.put(1, list);
        keyTable.put(key, freqTable.get(1).getHead());
        minfreq = 1;
    }

    //增加key的freq
    public void increaseFreq(int key){
        Node node = keyTable.get(key);
        int val = node.val, freq = node.freq;
        freqTable.get(freq).remove(node);
        // 如果当前链表为空，我们需要在哈希表中删除，且更新minFreq
        if (freqTable.get(freq).size() == 0) {
            freqTable.remove(freq);
            if (minfreq == freq) {
                minfreq++;
            }
        }
        // 插入到 freq + 1 中
        DoubleList list = freqTable.getOrDefault(freq + 1, new DoubleList());
        list.addFirst(new Node(key, val, freq + 1));
        freqTable.put(freq + 1, list);
        keyTable.put(key, freqTable.get(freq + 1).getHead());
    }

    //删除最久最少未使用的元素
    public void removeMinFreqKey(){
        // 通过 minFreq 拿到 freqTable[minFreq] 链表的末尾节点
        Node node = freqTable.get(minfreq).getTail();
        keyTable.remove(node.key);
        freqTable.get(minfreq).remove(node);
        if (freqTable.get(minfreq).size() == 0) {
            freqTable.remove(minfreq);
        }
    }
}

//底层数据结构：双链表
class Node{
    public int key, val, freq;
    public Node next, prev;
    public Node(int k, int v, int f){
        this.key = k;
        this.val = v;
        this.freq = f;
    }
}

class DoubleList {
    //头尾虚节点
    private Node head, tail;
    //链表元素数
    private int size;

    public DoubleList() {
        head = new Node(-1, -1, 0);
        tail = new Node(-1, -1, 0);
        head.next = tail;
        tail.prev = head;
        size = 0;
    }

    public void addFirst(Node node) {
        Node prevHead = head.next;
        node.prev = head;
        head.next = node;
        node.next = prevHead;
        prevHead.prev = node;
        size++;
    }

    public void remove(Node x) {
        x.prev.next = x.next;
        x.next.prev = x.prev;
        size--;
    }

    public Node getHead() {
        return head.next;
    }

    public Node getTail() {
        return tail.prev;
    }

    //获取链表大小
    public int size(){
        return size;
    }
}

第二种： 使用Java的HashMap和LinkedHashSet来实现

class LFUCache {
    //从key到val的映射，后面称为KV表
    HashMap<Integer, Integer> keyToVal;
    //从key到freq的映射，后面称为KF表
    HashMap<Integer,Integer> keyToFreq;
    //从freq到key列表的映射，后面称为FK表
    HashMap<Integer, LinkedHashSet<Integer>> freqToKeys;
    //记录最小的频次
    int minFreq = 0;
    //记录缓存容量
    int cap;

    public LFUCache(int capacity) {
        keyToVal = new HashMap<>();
        keyToFreq = new HashMap<>();
        freqToKeys = new HashMap<>();
        this.minFreq = 0;
        this.cap = capacity;
    }
    
    //获取元素
    public int get(int key) {
        if(!keyToVal.containsKey(key)){
            return -1;
        }
        //增加key的freq
        increaseFreq(key);

        return keyToVal.get(key);
    }
    
    //添加元素
    public void put(int key, int value) {
        if(this.cap <= 0){
            return;
        }

        //如果key已经存在，修改对应的value即可
        if(keyToVal.containsKey(key)){
            keyToVal.put(key, value);
            //key对应的freq+1即可
            increaseFreq(key);
            return;
        }

        //如果key不存在，插入新数据

        //如果缓存容量满了，删除最久最少未使用的元素
        if(this.cap <= keyToVal.size()){
            removeMinFreqKey();
        }

        //插入KV表
        keyToVal.put(key, value);
        //插入KF表
        keyToFreq.put(key, 1);
        //插入FK表
        freqToKeys.putIfAbsent(1, new LinkedHashSet<>());
        freqToKeys.get(1).add(key);
        //插入新key后最小的freq肯定是1
        this.minFreq = 1;
    }

    //增加key的freq
    public void increaseFreq(int key){
        int freq = keyToFreq.get(key);
        //更新KF表
        keyToFreq.put(key, freq + 1);
        //更新FK表
        //将key从freq对应的列表中删除
        freqToKeys.get(freq).remove(key);
        //将key添加到freq+1对应的列表中
        freqToKeys.putIfAbsent(freq + 1, new LinkedHashSet<>());
        freqToKeys.get(freq + 1).add(key);

        //如果freq对应的列表空了，删除这个列表
        if(freqToKeys.get(freq).isEmpty()){
            freqToKeys.remove(freq);
            //如果这个freq恰好是minFreq，更新minFreq
            if(freq == this.minFreq){
                minFreq++;
            }
        }
    }

    //删除最久最少未使用的元素
    public void removeMinFreqKey(){
        //获取freq最小的列表
        LinkedHashSet<Integer> keyList = freqToKeys.get(this.minFreq);
        //获取最久未使用的key
        int deleteKey = keyList.iterator().next();

        //删除FK表中的deleteKey
        keyList.remove(deleteKey);
        if(keyList.isEmpty()){
            freqToKeys.remove(this.minFreq);
        }

        //删除KV表中的deleteKey
        keyToVal.remove(deleteKey);
        //删除KF表中的deleteKey
        keyToFreq.remove(deleteKey);
    }
}