leetcode460. LFU缓存

请你为 最不经常使用（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

答：
其实着道题的意思理解之后，就可以有思路了。
就是按照使用次数times排序,当times一致时，谁更晚操作就把谁放在后面。
本来计划使用PriorityQueue的，但是只有在删除最小节点和插入时较快(也是O(lgn),不是O(1))，对于查询很慢很慢。
第二反应是，使用TreeMap+链表的方式，TreeMap的key是times(应该是可行的)。
最后使用的是使用链表保存数据，保持链表有序(以times排序)。
光只有链表也不行，每次移动可能会要很久，所以加入lastMap，来进行快速移动(比如，我的node的times由3改成4，那我就移动到last(4)后面)。

代码：

class LFUCache {
    Node head;
    int capacity;
    int sum = 0;
    //保存key和Node的关系
    Map<Integer, Node> ansMap;
    //保存times和Node关系(每次移动节点时候，知道移动到哪)
    Map<Integer, Node> lastMap;
    //当capacity为1时，直接使用
    int key = 0;
    int value = -1;

    public LFUCache(int capacity) {
        this.capacity = capacity;
        if (capacity <= 1) {
            return;
        } else {
            ansMap = new HashMap<>(capacity);
            lastMap = new HashMap<>();
        }
    }

    public int get(int key) {
        if (capacity <= 0) {
            return -1;
        } else if (capacity == 1) {
            if (key == this.key) {
                return value;
            } else {
                return -1;
            }
        }
        Node ans = ansMap.get(key);
        if (ans != null) {
            //校验是否在lastMap中
            checkLast(ans);
            //次数+1
            ans.times++;
            //移动node的位置
            moveNext(ans);
        } else {
            return -1;
        }
        return ans.value;
    }

    public void put(int key, int value) {
        if (capacity <= 0) {
            return;
        }
        if (capacity == 1) {
            this.key = key;
            this.value = value;
            return;
        }
        Node node = new Node();
        node.times = 1;
        node.key = key;
        node.value = value;
        if (head == null) {
            //head
            head = node;
            ansMap.put(key, node);
            lastMap.put(1, node);
            sum++;
        } else {
            Node ans = ansMap.get(key);
            if (ans != null) {
                //这时候的操作其实和get差不多，除了更新value值
                checkLast(ans);
                ans.times++;
                ans.value = value;
                moveNext(ans);
            } else {
                if (sum >= capacity) {
                    //我只保存capacity个数据，所以要移除head
                    ansMap.remove(head.key);
                    if (head.times != head.next.times) {
                        lastMap.remove(head.times);
                    }
                    head = head.next;
                }
                ansMap.put(key, node);
                if (head.times > 1) {
                    //我要插在首位了
                    node.next = head;
                    head.pre = node;
                    head = node;
                    lastMap.put(1, head);
                } else {
                    addNext(lastMap.get(1), node);
                }
                sum++;
            }
        }
    }

    //如果属于lastMap，进行删除
    private void checkLast(Node node) {
        if (lastMap.get(node.times) == node) {
            if (node.pre != null && node.pre.times == node.times) {
                lastMap.put(node.times, node.pre);
            } else {
                lastMap.remove(node.times);
            }
        }
    }

    //在nodeL后面插入node
    private void addNext(Node nodeL, Node node) {
        lastMap.put(node.times, node);
        if (nodeL.next == null) {
            nodeL.next = node;
            node.pre = nodeL;
            node.next = null;
            return;
        } else {
            nodeL.next.pre = node;
            node.next = nodeL.next;
            nodeL.next = node;
            node.pre = nodeL;
        }
    }

    private void moveNext(Node node) {
        Node next = node.next;
        if (next == null || node.times < next.times) {
            //无需移动，只要修改lastMap
            lastMap.put(node.times, node);
            return;
        }
        //移除node位置
        if (node == head) {
            head = node.next;
        } else {
            node.pre.next = node.next;
            node.next.pre = node.pre;
        }
        Node add = lastMap.get(node.times);
        if (add == null) {
            //都是k次，且不是last，恰好k+1次无数据，这时候插在last(k)后面
            addNext(lastMap.get(node.times - 1), node);
        } else {
            //插在add后面
            addNext(add, node);
        }
    }
}

class Node {
    int times;
    int key;
    int value;
    Node pre;
    Node next;
}