LRU（Least Recently Used） cache.

class LRUCache 
{
    
    Map<Integer, DlinkedNode> map;
    DlinkedNode head;
    DlinkedNode tail;
    int capacity;
    int count;
    public LRUCache(int cap) 
    {
        map = new HashMap<>();
        head = new DlinkedNode(-1, -1);
        tail = new DlinkedNode(-1, -1);
        capacity = cap;
        count = 0;
        head.right = tail;
        tail.left = head;
    }   
    public int get(int key) 
    {
        if(!map.containsKey(key)) return -1;
        DlinkedNode node = map.get(key);
        moveTohead(node);
        return node.val;
    }  
    public void put(int key, int value) 
    {
        if(!map.containsKey(key))
        {
            DlinkedNode node = new DlinkedNode(key, value);
            map.put(key, node);
            addToHead(node);
            count++;
            if(count > capacity)
            {
                DlinkedNode deleNode = tail.left;
                removeTail(deleNode);
                map.remove(deleNode.key);
                count--;
            }
        }
        else
        {
            DlinkedNode node = map.get(key);
            node.val = value;
            map.put(key, node);
            moveTohead(node);
        }
    }

    public void addToHead(DlinkedNode node)
    {
        node.right = head.right;
        node.left = head;
        head.right.left = node;
        head.right = node;
    }
    public void removeTail(DlinkedNode node)
    {
        DlinkedNode pre = node.left;
        DlinkedNode post = node.right;
        pre.right = post;
        post.left = pre;
    }
    public void moveTohead(DlinkedNode node)
    {
        removeTail(node);
        addToHead(node);
    }
    
}

class DlinkedNode
{
    int key;
    int val;
    DlinkedNode left;
    DlinkedNode right;
    public DlinkedNode(int k, int v)
    {
        key = k;
        val = v;
        left = null;
        right = null;
    }
}