双向链表+哈希表（likou146 LRU缓存机制）

146. LRU 缓存机制

难度 : 中等

运用你所掌握的数据结构，设计和实现一个  LRU (最近最少使用) 缓存机制 。
实现 LRUCache 类：

LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。
 

进阶：你是否可以在 O(1) 时间复杂度内完成这两种操作？

hashmap 查询和添加都是O(1)，因为hashmap记录的是双向链表的地址，知道前置链表和后置链表，所以查询链表数据结构中的数据也是o(1)，添加也是o(1)

（必须用链表，利用其它数据结构会超时）

示例：

输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1);    // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2);    // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1);    // 返回 -1 (未找到)
lRUCache.get(3);    // 返回 3
lRUCache.get(4);    // 返回 4

class LRUCache {

    HashMap<Integer, List> hashMap = new HashMap<>();
    List head;
    List tail;
    int size = 0;
    int count = 0;
    class List {
        int key;
        int value;
        List pre;
        List next;

        public List() {
        }

        public List(int key1, int value2) {
            key = key1;
            value = value2;
        }
    }

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

    public int get(int key) {
        if (hashMap.getOrDefault(key, null) == null) {
            return -1;
        } else {
            List list = hashMap.get(key);
            remove(list);
            addHead(list);
            return list.value;
        }
    }

    public void put(int key, int value) {

        if (hashMap.getOrDefault(key,null) == null){
            List list = new List(key,value);
            hashMap.put(key,list);
            addHead(list);
            count ++;
            if (count > size){
                int flag =removeTail();
                hashMap.remove(flag);
                count--;
            }
        }else {
            List list = hashMap.get(key);
            list.value = value;
            remove(list);
            addHead(list);
        }
    }

    public void remove(List list) {
        list.pre.next = list.next;
        list.next.pre = list.pre;
    }

    public void addHead(List list) {
        list.next =  head.next;
        list.pre = head;
        head.next.pre = list;
        head.next = list;
    }

    public int removeTail() {
        int list = tail.pre.key;
        tail.pre.next = null;
        tail = tail.pre;
        return list;
    }
}

1、先创建一个双向链表，用于存储数据，count记录链表的长度

2、使用hashMap存储链表的地址  HashMap<Integer, List> hashMap = new HashMap<>();

put时，先判断hashMap中是否存在对应的key的链表地址，如果存在获取到该链表的地址（就知道该链表对应的指向的前节链表，和后节链表），修改对应的value值，hashmap不需要进行修改，因为hashmap存储的地址，在链表上删除对应的链表节点，然后添加到头部（更新成最新数据）。如果不存在直接添加，然后判断count是否大于size的值，如果大于删除链表尾部的节点。

使用链表需要注意：

1 、防止后节点丢失，

例如1->2->3

1 = 4;

后面的节点就会丢失，需要先把后节点存储下来，

flag = 2 -> 3

1 = 4;

然后就可以利用1节点后面的数据了

2、list.next 和List list区别

 其实list.next存放的就是下一个list节点的地址（就是无线套娃的过程）。

操作：

next  叫做指向 （动态，给人的感觉会动（往后移动后者往前移动）,其实下一个next就是list）

list    叫做赋值   （静态，（它必须借助next才能移动））

（感觉只能说对于某一个节点才可以这么说，因为从整体上来说，next和list基本上相同，只是第一个地址一定为list，最后一个地址一定为next）