双向链表+HashMap 实现LRU算法（leetcode 416）

import java.util.HashMap;

/**
 * @author MasterYee
 * @Description：
 * @date: 2020/3/29
 */
public class LRUCache {
    class Node{
        int key;
        int value;
        Node pre;
        Node next;
    }
    public HashMap<Integer,Node> hashMap ;

    public Node head;
    public Node tail;
    public int capacity;
    public int size;

    public LRUCache(int capacity) {
        this.head = new Node();
        this.tail = new Node();
        this.hashMap = new HashMap<>();
        this.head.next = tail;
        this.tail.pre = head;
        this.capacity = capacity;
        this.size = 0;
    }

    // 往头插入node
    public void addNode(Node node){
        node.pre = this.head;
        node.next = this.head.next;

        this.head.next.pre = node;
        this.head.next = node;
    }

    // 把节点放到最前
    public void moveToHead(Node node){
        removeNode(node);
        addNode(node);
    }

    public void removeNode(Node node){
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }

    public Node popTail(){
        Node res = this.tail.pre;
        removeNode(this.tail.pre);
        return res;
    }

    public void put(int key,int value){
        Node node = new Node();
        node.key = key;
        node.value = value;

        Node oldNode = this.hashMap.get(key);
        // 不存在key重复
        if(oldNode == null){
            addNode(node);
            this.hashMap.put(key,node);
            
            // 插入后判断大小 超出则将最老的节点移除
            if(++this.size>capacity){
                Node tail = popTail();
                this.hashMap.remove(tail.key);
                size --;
            }
        }else{
            // 更新值,并设置到头
            oldNode.value = value;
            moveToHead(oldNode);
        }
    }

    public int get(int key){
        Node node = this.hashMap.get(key);
        if(node == null) return -1;

        moveToHead(node);
        return node.value;
    }
}

LRU（Least Recently Used 最近最少使用）：常用于缓存更新算法。有一说一缓存大小是固定的，一般是缓存满了后就把最近最老那个资源给删掉，新资源入缓存；每次读取缓存时会刷新当前资源的年龄。

思路

• 肯定是顺序表实现：每次插入put时往头部put，满了之后将尾部删除，每次get后将当前节点删除、并put到头部，put时若重复了，则覆盖原有值并将其放入头部。
• 用数组实现：读数能在O(1)时间内，但是缓存满了后再put、和读数后的刷新时间会引起数组结构变化，众所周知数组的增删是O(n)的
• 用链表实现：保证了新增时和刷新时（删除当前节点、再往头新增当前节点）都是O(1)，但是读数慢
• 用双向链表+HashMap：hashmap保证了读取是O(1)，链表保证增删是O(1)，双向保证不论是头（新增是往头增）还是尾（删除是从尾删）的增删是O(1)
• 双向链表可以预留一个head和tail，这样不用做判空处理，方便很多
• 实际上JDK中的LinkedHashMap就能满足要求

这道题据说字节跳动经常考，且要求手撕（不允许用LinkedHashMap，但允许用HashMap，那这就是标准答案）