[刷题]LRU Cache

[LintCode]LRU Cache

public class Solution {

    // 哈希表被当做一个索引表，用来查找所有Node  
    // 哈希表的key和Node的key相同  
    // Node之间用双向链表维护  
    private HashMap<Integer, Node> map;
    private Node first, last;
    private int capacity;
    
    // @param capacity, an integer
    public Solution(int capacity) {
        // 2015-09-04
        map = new HashMap<>();
        first = new Node(0, 0);
        last = new Node(0, 0);
        first.next = last;
        last.pre = first;
        this.capacity = capacity;
    }


    // @return an integer
    public int get(int key) {
        if (!map.containsKey(key)) {
            return -1;
        }
        Node temp = map.get(key);
        delectNode(temp);
        moveToTail(temp);
        return temp.val;
    }


    // @param key, an integer
    // @param value, an integer
    // @return nothing
    public void set(int key, int value) {
        if (get(key) != -1) {
            map.get(key).val = value;
            return;
        }
        if (map.size() == capacity) {
            map.remove(first.next.key);
            delectNode(first.next);
        }
        map.put(key, new Node(key, value));
        moveToTail(map.get(key));
    }
    
    /**
     * 从双向链表中删掉这个节点
     */
    private void delectNode(Node tar) {
        tar.pre.next = tar.next;
        tar.next.pre = tar.pre;
    }
    
    /**
     * 将该节点移到双向链表的尾部，last之前
     */
    private void moveToTail(Node tar){
        tar.pre = last.pre;
        tar.next = last;
        last.pre.next = tar;
        last.pre = tar;
    }
    
    /**
     * 内部类，节点
     */
    private class Node {
        int key, val;
        Node next, pre;
        public Node(int key, int val) {
            this.key = key;
            this.val = val;
            next = null;
            pre = null;
        }
    }
}