LeetCode 460. LFU Cache

题目：

• Design and implement a data structure for Least Frequently Used (LFU) cache. It should support the following operations: get and put.

• get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.

• put(key, value) - Set or insert the value if the key is not already present. When the cache reaches its capacity, it should invalidate the least frequently used item before inserting a new item. For the purpose of this problem, when there is a tie (i.e., two or more keys that have the same frequency), the least recently used key would be evicted.

• Could you do both operations in O(1) time complexity?

LFUCache cache = new LFUCache( 2 /* capacity */ );cache.put(1, 1);cache.put(2, 2);cache.get(1);       // returns 1cache.put(3, 3);    // evicts key 2cache.get(2);       // returns -1 (not found)cache.get(3);       // returns 3.cache.put(4, 4);    // evicts key 1.cache.get(1);       // returns -1 (not found)cache.get(3);       // returns 3cache.get(4);       // returns 4

思路：

• 变量

  • key——键
  • value——值
  • num——key被使用的次数，包括get和put（对已有key的put是更新，也要num++）

• 容器

  • HashMap<Integer,int[]> valueHashMap——存储<key,int[value,num]>
  • TreeMap<Integer,LinkedHashSet<Integer>> numTreeMap——存储num,list<key>

• numTreeMap为了确定容量不足时该删除谁，其中TreeMap能在O(1)时间复杂度保证最小frequency，LinkedHashSet能在O(1)时间复杂度remove开头key，remove任意key，add。

• valueHashMap中存储的num是一份冗余信息，相当于索引，保证plusToTreeMap时，可以在O(1)的时间复杂度锁定位置。

代码：

public class LFUCache {    private TreeMap<Integer,LinkedHashSet<Integer>> numTreeMap; // k:num,v:timeLinkedHashSet    private HashMap<Integer,int[]> valueHashMap; // k:key,v:int[value,num]    private int capacity;    public LFUCache(int capacity) {        this.capacity = capacity;        numTreeMap = new TreeMap<>();        valueHashMap = new HashMap<>();    }    //这些调试用的打印语句，一定要记得注释掉，毕竟打印时间复杂度是O(n)...    public int get(int key) {        // System.out.println(numTreeMap.toString());        // System.out.println("~~~~~~~~~~~~~~~~~~~~get ("+key+")");        if(!valueHashMap.containsKey(key)){            // System.out.println("value: "+ -1);            return -1;        }        int v = valueHashMap.get(key)[0];        plusToTreeMap(key);        // System.out.println("value: "+ v);        return v;    }    public void put(int key, int value) {        // System.out.println(numTreeMap.toString());        // System.out.println("~~~~~~~~~~~~~~~~~~~~put ("+key+","+value+")");        if(capacity==0){            return;        }        if(valueHashMap.containsKey(key)){            plusToTreeMap(key);            valueHashMap.put(key,new int[]{value,valueHashMap.get(key)[1]});        }else{            if(valueHashMap.size()==capacity){                // System.out.println("remove!");                removeFromCache();            }            valueHashMap.put(key,new int[]{value,1});            addToTreeMap(key);        }    }    //新的key被put后，将valueHashMap中的num设成1，并在numTreeMap.get(1)中放入该key    private void addToTreeMap(int key){        LinkedHashSet<Integer> timeLinkedList;        if(!numTreeMap.containsKey(1)){            timeLinkedList = new LinkedHashSet<>();            numTreeMap.put(1,timeLinkedList);        }else{            timeLinkedList = numTreeMap.get(1);        }        timeLinkedList.add(key);    }    //已有key被get或put后，要修改两个地方，一个是valueHashMap中的num++，一个是提升该key在numTreeMap中的位置。    private void plusToTreeMap(int key){        LinkedHashSet<Integer> timeLinkedList;        int num = valueHashMap.get(key)[1]++;        timeLinkedList = numTreeMap.get(num);        timeLinkedList.remove(key);        if(timeLinkedList.size()==0){            numTreeMap.remove(num);        }        if(!numTreeMap.containsKey(num+1)){            timeLinkedList = new LinkedHashSet<>();            numTreeMap.put(num+1,timeLinkedList);        }else{            timeLinkedList = numTreeMap.get(num+1);        }        timeLinkedList.add(key);    }    // freshTreeMap函数的作用是将key提到当前次数的最后，开始时我以为put操作不影响frequently只影响recently，才写的这个，对本题来说没有作用。实际cache设计中我觉得使用该函数也许更合理    // private void freshTreeMap(int key){    //     LinkedHashSet<Integer> timeLinkedList;    //     int num = valueHashMap.get(key)[1];    //     timeLinkedList = numTreeMap.get(num);    //     timeLinkedList.remove(key);    //     timeLinkedList.add(key);    // }    //容器满了，又put了新的key，就需要调用removeFromCache，清理出一个空间。思路是先在numTreeMap找到最小frequently对应的时间队列timeLinkedList，再找到该队列的第一个元素，将它删除。如果此时timeLinkedList空了，要在numTreeMap中把该frequently的对应的timeLinkedList删除，保证以后numTreeMap.firstEntry().getValue()找到的timeLinkedList一定非空。    private void removeFromCache(){        LinkedHashSet<Integer> timeLinkedList = numTreeMap.firstEntry().getValue();        int k = timeLinkedList.iterator().next();        timeLinkedList.remove(k);        valueHashMap.remove(k);        if(timeLinkedList.size()==0){            numTreeMap.remove(numTreeMap.firstEntry().getKey());        }    }}/** * 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); */