LRU Cache

https://leetcode.com/problems/lru-cache/

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

解题思路：

这题其实不是太难，但是从不到15%的AC率就能看出来，很难bug free。

关键就在于每次get和set一个key的时候，就把它变为最新用过的，这样才能维护出the least recently used item。

若是用list，很容易实现。不过set一个已有的key的时候，需要在list中移除前面的key，然后在最后加上key，保证他是最新用过的。在list中，remove这个方法是要花O(n)的时间来找到一个元素的。所以下面的代码会超时。

public class LRUCache {

    Map<Integer, Integer> map = new HashMap<Integer, Integer>();

    LinkedList<Integer> list = new LinkedList<Integer>();

    int capacity;

    

    public LRUCache(int capacity) {

        this.capacity = capacity;

    }

    

    public int get(int key) {

        if(map.containsKey(key)) {

            list.remove(new Integer(key));

            list.add(key);

            return map.get(key);

        } else {

            return -1;

        }

    }

    

    public void set(int key, int value) {

        if(list.size() < capacity) {

            if(map.containsKey(key)) {

                list.remove(new Integer(key));

                list.add(key);

                map.put(key, value);

            } else {

                list.add(key);

                map.put(key, value);

            }

        } else {

            if(map.containsKey(key)) {

                list.remove(new Integer(key));

                list.add(key);

                map.put(key, value);

            } else {

                map.remove(list.get(0));

                list.remove(0);

                list.add(key);

                map.put(key, value);

            }

        }

    }

}

那不用想了，题目一定是要O(1)的时间，那么就无外乎map来做了。而且，不能用Java自带的List，因为这个List无法自己指定顺序，就是像链表那样进行O(1)的删除和插入操作。只能定义了一个内部类，借用前面一直使用的ListNode这个class。

这里我维护了几个变量，注释里写了。为了立刻得到key对应的节点，然后删除它，并将它加入到链表尾部，必须维护一个map，value就是key在链表中的前置节点。last就是链表的尾部节点。key可以直接加在后面。

public class LRUCache {

    public class ListNode {

        int val;

        ListNode next;

        ListNode(int x) {

            val = x;

            next = null;

        }

    }

    

    //保存真正键值对

    Map<Integer, Integer> map = new HashMap<Integer, Integer>();

    //保存一个key在链表中的前一个节点

    Map<Integer, ListNode> nodeMap = new HashMap<Integer, ListNode>();

    //dummy节点，时刻位于链表的首位

    ListNode dummy = new ListNode(0);

    //lastNode时候指向链表的最后一个节点，主要为了在它后面add节点用

    ListNode lastNode = dummy;

    int capacity;

    

    public LRUCache(int capacity) {

        this.capacity = capacity;

    }

    

    public int get(int key) {

        if(map.containsKey(key)) {

            if(lastNode.val != key) {

                ListNode pre = nodeMap.get(key);

                nodeMap.put(pre.next.next.val, pre);

                lastNode.next = pre.next;

                pre.next = pre.next.next;

                lastNode.next.next = null;

                nodeMap.put(key, lastNode);

                lastNode = lastNode.next;

            }

            return map.get(key);

        } else {

            return -1;

        }

    }

    

    public void set(int key, int value) {

        if(map.size() < capacity) {

            ListNode pre = nodeMap.get(key);

            

            ListNode next = new ListNode(key);

            lastNode.next = next;

            nodeMap.put(key, lastNode);

            lastNode = next;

            

            if(map.containsKey(key)) {

                nodeMap.put(pre.next.next.val, pre);

                pre.next = pre.next.next;

            }

            map.put(key, value);

        } else {

            ListNode pre = nodeMap.get(key);

            

            ListNode next = new ListNode(key);

            lastNode.next = next;

            nodeMap.put(key, lastNode);

            lastNode = next;

            

            if(map.containsKey(key)) {

                nodeMap.put(pre.next.next.val, pre);

                pre.next = pre.next.next;

            } else {

                nodeMap.remove(new Integer(dummy.next.val));

                map.remove(new Integer(dummy.next.val));

                nodeMap.put(dummy.next.next.val, dummy);

                dummy.next = dummy.next.next;

            }

            map.put(key, value);

        }

    }

}

逻辑并不复杂，代码比较繁琐，比较容易疏漏。特别是nodeMap的维护，在链表发生任意变化的时候，nodeMap都要进行更新，非常容易疏忽。

update

把第一个解法的LinkedList换成ArrayList，居然AC了。。。

好吧，这里只说结论，而且是肯定的。除非用到LinkedList的deque特性，否则永远都尽量使用ArrayList。Java里LinkedList，无论是remove(Object o)还是remove(int index)，都要耗时O(n)，而不是O(1)。因为需要首先找到这个第一个Object o，或者index的位置。虽然ArrayList的两个remove方法也要耗时O(n)，但这里的耗时主要是花在将后面的元素移动上。与LinkedList不断往后寻址相比，要快得多。

而且LinkedList要维护一个复杂的数据结构Entry，要花费很多额外的内存。

于是，在for循环中使用remove，LinkedList就要总共花费O(n^2)了，OMG！但是，使用iterator循环，然后调用it.remove，却只要O(1)的时间，总计就是O(n)，因为已经定位到这个元素了。而且iterator还能避免remove后下标变化的问题，这个是要特别注意的。

http://www.blogjava.net/killme2008/archive/2010/09/16/332168.html

http://xiaozu.renren.com/xiaozu/100134/331695692

http://stackoverflow.com/questions/322715/when-to-use-linkedlist-over-arraylist

http://www.exceptionhelp.com/javadetail?articleId=551

public class LRUCache {

    Map<Integer, Integer> map = new HashMap<Integer, Integer>();

    List<Integer> list = new ArrayList<Integer>();

    int capacity;

    

    public LRUCache(int capacity) {

        this.capacity = capacity;

    }

    

    public int get(int key) {

        if(map.containsKey(key)) {

            list.remove(new Integer(key));

            list.add(key);

            return map.get(key);

        } else {

            return -1;

        }

    }

    

    public void set(int key, int value) {

        if(list.size() < capacity) {

            if(map.containsKey(key)) {

                list.remove(new Integer(key));

                list.add(key);

                map.put(key, value);

            } else {

                list.add(key);

                map.put(key, value);

            }

        } else {

            if(map.containsKey(key)) {

                list.remove(new Integer(key));

                list.add(key);

                map.put(key, value);

            } else {

                map.remove(list.get(0));

                list.remove(0);

                list.add(key);

                map.put(key, value);

            }

        }

    }

}