#leetcode#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.

分析： HashTable + DoublyLinkedList, LRU Cache中维护两个Node， first， last， 越靠近last的表示越least recently used，每次做get， set操作的时候，当前节点是 least recently used， 需要把他移动到LRU Cache中的last， 主要就是判断当前节点是否为first或者last，还有就是判断当前LRU的first/last 是否为null，学习了Code ganker大神的解法http://blog.csdn.net/linhuanmars/article/details/21310633， 看了思路之后自己试着写了个适合自己的版本

public class LRUCache {
    class Node{
        Node pre;
        Node next;
        int val;
        int key;
        public Node(int key, int val){
            this.val = val;
            this.key = key;
        }
    }
    
    private int capacity;
    private int num;
    private Node first;
    private Node last;
    private Map<Integer, Node> map;
    
    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.num = 0;
        this.map = new HashMap<Integer, Node>();
    }
    
    public int get(int key) {
        Node node = map.get(key);
        if(node == null){
            return -1;
        }
        if(node != last){
            if(node == first){
                first = first.next;
                if(first != null){
                    first.pre = null;
                }
            }else{
                node.next.pre = node.pre;
                node.pre.next = node.next;
            }
            last.next = node;
            node.pre = last;
            last = node;
            node.next = null;
        }
        return node.val;
    }
    
    public void set(int key, int value) {
        Node node = map.get(key);
        if(node == null){
            node = new Node(key, value);
            map.put(key, node);// don't forget to add new entry for new key - node pair.
            if(first == null){
                first = node;
                last = node;
                num++;
            }else{
                if(num == capacity){
                    map.remove(first.key);// don't forget to delete map key
                    first = first.next;
                    if(first != null){
                        first.pre = null;
                    }
                }else{
                    num++;
                }
                last.next = node;
                node.pre = last;
                last = node;
            }
        }else{
            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.pre = last;
                last = node;
            }
        }
    }
}