LRU缓存机制

LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。
那么我们怎么能够实现一个LRU缓存呢?
1.先创建两个哨兵节点，一个为head，一个为tail；创建这两个节点作用就是更加容易的插入和删除，我们将要插入的节点从tail节点的地方插入进来，要删除的节点放在head的写一个节点。


为了达到O（1）的时间复杂度，我们可以在类中维护一个哈希表，目的就是为了删除的时候可以直接定位node，不然的话就需要遍历节点，此时的时间复杂度就是O（n）了。

class LRUCache {
    MyLru lru = null;
    public LRUCache(int capacity) {
            lru = new MyLru(capacity);
    }
    
    public int get(int key) {
      return   lru.get(key);
    }
    
    public void put(int key, int value) {
            lru.set(key,value);
    }
    class Node{   //因为双链表，所以需要next和pre
        int val ;
        int key;
        Node pre;
        Node next;
        public Node(int key , int val){
                this.key = key;
                this.val  = val;
        }
    }
    class MyLru{
        int size;
        int cap ;
        Node head = new Node(-1,-1);//设置头哨兵节点
        Node tail = new Node(-1,-1);//设置尾哨兵节点
        Map<Integer , Node> map  =  new HashMap<>();//维护一个hash表
        public MyLru(int cap){  //初始化时将head和tail连接起来
                this.cap = cap;
                head.next = tail;
                tail.pre = head;
        }
        public void set(int key ,int val){  
                Node tmp = map.get(key);
                if(tmp != null){   //首先判断hash表里有没有这个node，有的话讲他的值更新，并删除它再将它加进来（为了保持最新）；
                    tmp.val = val;
                    delete(tmp);
                    add(tmp);

                }else{//如果没有的话，判断当前size（）看是否capacity已经满了，如果满了就需要移除最近最少使用节点再加入，若没满，直接加入就ok。
                   Node nd =  new Node(key,val);
                    if(size >= cap){
                        delete(head.next);
                        add(nd);
                    }else{
                        add(nd);
                    }

                }

        }
        public  int get(int key){
            Node node = map.get(key);//判断当前节点是否存在，不存在的话返回-1
            if(node == null ){
                return -1;
            }
            delete(node);  //若存在，删除它，并且重新加入，返回它的节点值，证明它最近使用过了。
            add(node);
            return node.val;

        }
        public void  add(Node node ){//从尾部添加节点，并将size+1;
              map.put(node.key,node);
              node.next = tail;
              node.pre = tail.pre;
            tail.pre.next = node;
            tail.pre = node;
            size++;
        }
        public void delete(Node node){  //删除中间节点
            map.remove(node.key);
             
               node.pre.next = node.next;
               node.next.pre = node.pre;
                 size--;
        }

    }
}