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.

思路：

这个题被问过很多次。感觉是背过了。。很多都是上来让我说说要用什么data structure，然后整体的想法是怎样的。所以脑子里得有个框架。我回答的是当时看大神code ganker提供的解法。用HashMap+Doubled LinkedList，使用这两种数据结构可以使查找与添加删除操作都为O(1)的时间。不说了，直接上代码吧。写的时候出了些错，记录在这里

public class LRUCache {
    class Node {
        Node pre, next;
        int key;
        int val;
        public Node(int key, int value) {
            this.key = key;
            this.val = value;
        }
    }
    
    private int capacity; //
    private int num;  //
    private HashMap<Integer, Node> map;  //
    private Node first, last;  //
    
    public LRUCache(int capacity) {
        this.capacity = capacity;
        num = 0;
        map = new HashMap<Integer, Node>();
        first = null;
        last = null;
    }
    
    public int get(int key) {
        Node node = map.get(key);
        if (node == null) {
            return -1;
        }else if (node != last) {
            if (node == first) {
                first = first.next;
            }else{
                node.pre.next = node.next;
            }
            node.next.pre = node.pre;
            last.next = node;
            node.pre = last;
            node.next = null;
            last = node;
        }
        return node.val;
    }
    
    public void set(int key, int value) {
        Node node = map.get(key);
        if (node != null) {
            node.val = value;
            if (node != last) {
                if (node == first) {
                    first = first.next;
                }else{
                    node.pre.next = node.next;
                }
                node.next.pre = node.pre;
                last.next = node;
                node.next = null;
                node.pre = last;
                last = node;
            }
        }else{
            Node newNode = new Node(key, value);
            
            //remove element if cache is full
            if (num >= capacity) {
                map.remove(first.key);//need provide a key to romve()
                first = first.next;
                if (first != null) {
                    first.pre = null;
                //BUG: need to check first != null first. If it is null, then there is only one element.
                //then set it to null;
                }else{
                    last = null;
                }
                num--;
            }
            //if there is 0 element in cache. 
            if (first == null && last == null) {
                first = newNode;
                last = newNode;
            }else{
                last.next = newNode;
                newNode.pre = last;
                last = newNode;
            }
            map.put(key, newNode);
            num++;
        }
    }
}