Lint Code：LRU缓存策略

描述

为最近最少使用（LRU）缓存策略设计一个数据结构，它应该支持以下操作：获取数据（get）和写入数据（set）。

获取数据get(key)：如果缓存中存在key，则获取其数据值（通常是正数），否则返回-1。

写入数据set(key, value)：如果key还没有在缓存中，则写入其数据值。当缓存达到上限，它应该在写入新数据之前删除最近最少使用的数据用来腾出空闲位置。

思路： 

下图是借用的别人的一张图，展示了LRU算法的流程，LRU删除的是最近最久未使用的哪些对象，如果一个对象已经在内存中，被使用过一次后，就要更新他的时间戳。

实现的话我们使用HashMap+双端链表来实现的，HashMap的结构是<Key, Node>， Node就是双端链表中的一个节点，这样我们可以根据这个Key快速找到链表中的一个节点，这样每次将他移动到链表末端也会很方便。

Java实现如下：

public class LRUCache {
    private class Node{
        Node prev;
        Node next;
        int key;
        int value;


        private Node(int key, int value){
            this.key = key;
            this.value = value;
        }
    }
    private int capacity;
    public HashMap<Integer,Node> hashmap = new HashMap<>();
    private Node head = new Node(-1,-1);
    private Node tail = new Node(-1,-1);


    public LRUCache(int capacity) {
        this.capacity = capacity;
        head.next = tail;
        tail.prev = head;
    }


    /*
     * @param key: An integer
     * @return: An integer
     */
    public int get(int key) {
        if(!hashmap.containsKey(key)){
            return -1;
        }


        //  remove current node
        Node current = hashmap.get(key);
        current.prev.next = current.next;
        current.next.prev = current.prev;
        //  move current node to tail
        move_to_tail(current);
        return current.value;
    }


    public void move_to_tail(Node node){
        node.prev = tail.prev;
        tail.prev = node;
        node.next = tail;
        node.prev.next = node;
    }


    public void set(int key, int value) {
        if(get(key)!=-1){
            hashmap.get(key).value = value;
            return;
        }


        if(hashmap.size()==capacity){
            hashmap.remove(head.next.key);
            head.next = head.next.next;
            head.next.prev = head;
        }


        Node node = new Node(key, value);
        hashmap.put(key, node);
        move_to_tail(node);
    }
}