146. LRU 缓存

请你设计并实现一个满足  LRU (最近最少使用) 缓存 约束的数据结构。
实现 LRUCache 类：
LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。
函数 get 和 put 必须以 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
 

提示：

1 <= capacity <= 3000
0 <= key <= 10000
0 <= value <= 105
最多调用 2 * 105 次 get 和 put

解题思路

1. 双向链表+哈希表解题
2. 双向链表存放 key和value，哈希表存放key对应双向链表的地址
3. 当哈希表的key被更新或者被访问时，就要把该key对应双向链表的节点移到表头，只有双向指针才可以把移除节点后的表拼接回来，表尾指向最久未被更新或访问的节点，当容量不足时要把表尾节点删除，同时注意删除哈希表的元素
4. 注意哈希表元素为一个的时候，访问该元素时，不需要改变其在链表的位置，因为只有一个节点
5. 把节点移到链表表头时，有三种情况，1是该节点是表头，2是该节点是表尾，3是该节点既不是表头也不是表尾
6. 注意当更新的是已经存在的key时，就不需要考虑容量满的问题，因为只是value覆盖而key还是原来的key

class LinkNode{
    int key;
    int val;
    LinkNode next;
    LinkNode font;
    public LinkNode(int key,int val){
        this.val=val;
        this.key=key;
    }
}
class LRUCache {
    private int capacity;
    private Map<Integer,LinkNode> map;
    private LinkNode head;
    private LinkNode tail;
    public LRUCache(int capacity) {
        this.capacity=capacity;
        this.map=new HashMap<>();
    }
    public int get(int key) {
        LinkNode current=map.get(key);
        if(current==null)
            return -1;
            Integer i=current.val;
        if(map.size()!=1&&current==tail){
            LinkNode t=tail;
            tail=tail.font;
            tail.next=null;
            t.next=head;
            head.font=t;
            t.font=null;
            head=t;
        }else if(map.size()!=1&&current!=head){
           LinkNode t= current;
           current.font.next=current.next;
           current.next.font=current.font;
           t.next=head;
            head.font=t;
            t.font=null;
            head=t;
        }
        
        return i;
    }
    public void put(int key, int value) {
        if(!map.containsKey(key)){
            if(this.capacity==map.size()){
                if(map.size()==1){
                    int key1=tail.key;
                    map.remove(key1);
                    head=null;
                    tail=null;
                }else{
                    int key1=tail.key;
                    tail=tail.font;
                    tail.next=null;
                    map.remove(key1);
                }
            }
                if(head==null){
                    head=new LinkNode(key,value);
                    head.next=null;
                    head.font=null;
                    map.put(key,head);
                    tail=head;
                }else{
                    LinkNode t=head;
                    LinkNode c=new LinkNode(key,value);
                    map.put(key,c);
                    head=c;
                    c.next=t;
                    t.font=c;
                    c.font=null;
                    if(t==tail){
                        tail=t;
                        tail.next=null;
                    }
                }
        }else{
            LinkNode linkNode = map.get(key);
            linkNode.val=value;
             if(map.size()!=1&&linkNode==tail){
                LinkNode t=tail;
                tail=tail.font;
                tail.next=null;
                t.next=head;
                head.font=t;
                t.font=null;
                head=t;
            }else if(map.size()!=1&&linkNode!=head){
                LinkNode t= linkNode;
                linkNode.font.next=linkNode.next;
                linkNode.next.font=linkNode.font;
                t.next=head;
                head.font=t;
                t.font=null;
                head=t;
            }
        }
       
    }
}