（链表）19-LRU缓存

public class LRUCache {

    // 双向链表节点的构造函数
    class DLinkedNode {
        // 双向链表-Key
        int key;
        // 双向链表-Val
        int value;
        // 双向链表-前指针
        DLinkedNode pre;
        // 双向链表-后指针
        DLinkedNode next;
        // 构造函数-空参数
        public DLinkedNode() {
        }
        // 构造函数-完全参数
        public DLinkedNode(int inputKey, int inputVal) {
            key = inputKey; 
            value = inputVal;
        }
    }

    // 哈希表
    private Map<Integer, DLinkedNode> cache = new HashMap<Integer, DLinkedNode>();
    // LRU缓存-已填充的数据量
    private int size;
    // LRU缓存-容量
    private int capacity;
    // 伪头结点
    private DLinkedNode head;
    // 伪尾结点
    private DLinkedNode tail;

    // LRU缓存构造函数
    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        // 添加伪头部和伪尾部节点
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head.next = tail;
        tail.pre = head;
    }

    public int get(int key) {
        DLinkedNode node = cache.get(key);
        // KEY不存在返回-1
        if (node == null) {
            return -1;
        }
        // 如果KEY存在-先通过哈希表定位-再移到头部
        moveToHead(node);
        // 返回KEY对应节点值
        return node.value;
    }

    public void put(int key, int value) {
        DLinkedNode node = cache.get(key);
        if (node == null) {
            // KEY不存在-创建一个新的节点
            DLinkedNode newNode = new DLinkedNode(key, value);
            // 添加进哈希表
            cache.put(key, newNode);
            // 添加至双向链表的头部
            addToHead(newNode);
            // 数据量+1
            size ++;
            if (size > capacity) {
                // 超出容量，删除双向链表的尾部节点
                DLinkedNode tail = removeTail();
                // 删除哈希表中对应的项
                cache.remove(tail.key);
                // 数据量-1
                size --;
            }
        } else {
            // KEY存在-先通过哈希表定位修改VAL
            node.value = value;
            // 将刚刚使用的节点移到头部
            moveToHead(node);
        }
    }

    // 将入参节点添加到头结点
    private void addToHead(DLinkedNode node) {
        node.pre = head;
        node.next = head.next;
        head.next.pre = node;
        head.next = node;
    }

    // 删除入参节点
    private void removeNode(DLinkedNode node) {
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }

    // 将入参节点移动到链表最前面
    private void moveToHead(DLinkedNode node) {
        removeNode(node);
        addToHead(node);
    }

    // 移除尾部结点-返回移除的节点
    private DLinkedNode removeTail() {
        DLinkedNode res = tail.pre;
        removeNode(res);
        return res;
    }
}