LRU实现

1. 使用双向链表实现最近最久未使用
2. 使用map保存节点对应的位置，实现O(logn)的查找和删除。

可以在O(logn)的时间复杂度内插入节点。如果容量大于了缓冲池，可以在O（logn）的时间复杂度内删除节点。

对于双向链表，有两种操作，插入到头和删除。

1. 每一次更新需要插入到头并且删除
2. 每一次插入，需要插入到头

对于map有两种操作

1. 如果增加，直接插入
2. 如果删除，需要注意删除的是尾节点对应的key

更新不用重新将node插入，因为map保存的node本来就是引用

class LRUCache {
    
    

    class Node {
    
    
        int val;
        int key;                // 删除尾节点的时候，需要从map中删除，从而需要这个key。
        Node next;
        Node pre;
        public Node(int _key, int _val) {
    
    
            this.key = _key;
            this.val = _val;
        }
        public Node() {
    
    }
    }
    int capacity;
    Node tail, head;
    HashMap<Integer, Node>store = new HashMap<>();
    public LRUCache(int capacity) {
    
    
        tail = new Node();
        head = new Node();
        head.next = tail;
        tail.pre = head;
        this.capacity = capacity;
    }
    
    public int get(int key) {
    
    
        if (!store.containsKey(key)) return -1;
        Node node = store.get(key);
        // 更新
        remove(node);
        addHead(node);
        return node.val;
    }

    
    public void put(int key, int value) {
    
    
        // 如果存在，变更
        if (store.containsKey(key)) {
    
    
            Node node = store.get(key);
            // 更新
            remove(node);
            addHead(node);
            node.val = value;
        }
        // 否则，插入
        else {
    
    
            Node node = new Node(key, value);
            // 如果已经满了
            if (store.size() >= capacity) {
    
    
                Node last = tail.pre;
                remove(last);
                store.remove(last.key);
            }
            // 插入
            addHead(node);
            store.put(key, node);
        }
    }

    private void remove(Node node) {
    
    
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }
    private void addHead(Node node) {
    
    
        node.next = head.next;
        node.pre = head;
        head.next = node;
        node.next.pre = node;
    }
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */