双链表+HashMap实现LRUCache

1. LRU缓存机制

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。

1. 获取数据 get(key) - 如果关键字 (key) 存在于缓存中，则获取关键字的值（总是正数），否则返回 -1。
2. 写入数据 put(key, value) - 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字/值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。
3. 进阶: 你是否可以在 O(1) 时间复杂度内完成这两种操作？
4. 示例:

LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );
cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // 返回  1
cache.put(3, 3);    // 该操作会使得关键字 2 作废
cache.get(2);       // 返回 -1 (未找到)
cache.put(4, 4);    // 该操作会使得关键字 1 作废
cache.get(1);       // 返回 -1 (未找到)
cache.get(3);       // 返回  3
cache.get(4);       // 返回  4

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/lru-cache
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2. 思考

单纯的实现一个cache，很简单。使用一个队列（队列的特点就是先进先出）就可以了，队列的元素是<key, value>数据对。每当get时，在队列里遍历一遍，查到后，将其取出放入队尾；每当put<key，value>时，首先进行遍历，如果队列中已经存在key值，那就将该结点移到队尾，然后更新其值；如果队中不存在key值：如果队列已满，就出队一个元素，然后再进行入队；否则直接入队该<key，value>对儿。但是这样每次都需要遍历一遍队列，时间复杂度为O(n)。
而题目中要求的常数时间操作，让我们立马想到了hash，现在需要我们考虑的是如何将hash和队列结合起来。HashMap起到的作用就是由一个key在常数时间找到<key，value>对儿。在找到<key，value>（在链表中就是一个node），然后就可以对这个node进行删除插入操作了，链表的插入和删除都是常数时间可以完成的操作。
队列为什么非要用双链表实现，而不是单链表呢？首先可以肯定的是不能用数组实现，因为数组的插入和删除是需要大量元素的移动的（虽然它的随机读（索引）速度很快）。单链表的插入和双链表没啥大的区别，区别主要在删除上，要删除一个结点p，双链表可以直接删，但是单链表必须得知道p的前驱，但是找前驱又得遍历链表，是一个O(n)操作。

3. 实现

package com.ftq.demo.leetcode;

import java.util.HashMap;
import java.util.Map;

public class LRUCache {
    public Dque cache;//用于存储数据
    public Map<Integer, DNode> search;//用于查找
    public int length;
    public int capacity;
// 双链表的结点类
    class DNode{
        public int key;
        public int value;
        DNode pre;
        DNode next;
        DNode(){};
        DNode(int key, int value){
            this.key = key;
            this.value = value;
            pre = null;
            next = null;
        }
    }
    //双链表类
    class Dque{
        DNode head;
        DNode tail;
        Dque(){
            head = new DNode();
            tail = new DNode();
            head.next = tail;
            tail.pre = head;
        }
//访问一个结点后，就将其挪到队尾
        public DNode visit(DNode node){
            // 删除node
            node.pre.next = node.next;
            node.next.pre = node.pre;
            // 插入队尾
            add(node);
            return node;
        }
//在队尾添加一个结点
        public void add(DNode node){//插到tail的前面
            //建立node到前面结点的连接
            tail.pre.next = node;
            node.pre = tail.pre;
            // 建立node到tail的连接
            node.next = tail;
            tail.pre = node;
        }
//删除队列头结点
        public DNode poll(){
            // 删除队列头
            if(head.next == tail && tail.pre == head) return null;

            DNode del = head.next;
            head.next = del.next;
            del.next.pre = head;
            return del;
        }
//更新队尾结点的值
        public void set(int key, int value){
            if(head.next == tail && tail.pre == head) return;
            tail.pre.key = key;
            tail.pre.value = value;
        }

    }

    public LRUCache(int capacity) {
        cache = new Dque();
        search = new HashMap<>();
        length = 0;
        this.capacity = capacity;
    }

    public int get(int key) {
        DNode node = search.getOrDefault(key, null);
        if(node != null){
            cache.visit(node);
            return node.value;
        }
        return -1;
    }

    public void put(int key, int value) {
        DNode node = search.getOrDefault(key, null);
        DNode newN = new DNode(key, value);
        if(node != null){//已经存在缓存中，需要更新
            cache.visit(node);
            cache.set(key, value);
        }else{//没在缓存中
            if(length == capacity){//需要替换
                DNode poll = cache.poll();
                search.remove(poll.key);
                length--;
            }
            cache.add(newN);
            search.put(key, newN);
            length++;
        }
    }

    public static void main(String[] args) {
        LRUCache cache = new LRUCache( 2);
        cache.put(1, 1);
        cache.put(2, 2);
        cache.get(1);       // 返回  1
        cache.put(3, 3);    // 该操作会使得关键字 2 作废
        cache.get(2);       // 返回 -1 (未找到)
        cache.put(4, 4);    // 该操作会使得关键字 1 作废
        cache.get(1);       // 返回 -1 (未找到)
        cache.get(3);       // 返回  3
        cache.get(4);       // 返回  4
    }
}

4. 继承LinkedHashMap

class Lru extends LinkedHashMap<Integer, Integer>{
    private int cap;
    Lru(int capacity){
        super(capacity, 0.75f, true);
        cap = capacity;
    }
    //必须要重写这个方法才可以
    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer,Integer> eldest) {
        if(size() > cap) return true;
        return false;
    }

    public int get(int key) {
        return super.getOrDefault(key, -1);
    }

    public void put(int key, int value) {
        super.put(key, value);
    }
}

还可以直接继承LinkedHashMap，并重写它的removeEldestEntry（）方法，当该方法返回真时，就会将最近最久未访问键值对删除。