LRU缓存

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) 的平均时间复杂度运行。

class LRUCache {
       //定义双向链表

      class DoubleLinkedListNode{
        DoubleLinkedListNode pre;
        DoubleLinkedListNode next;
        int key ;
        int val;
        public DoubleLinkedListNode(int key ,int val){
            this.key  =key ;
            this.val =val;
        }     
    }
     
     HashMap<Integer,DoubleLinkedListNode> map;  // 用来存放（key，node）的map
     DoubleLinkedListNode head;                  // 头节点
     DoubleLinkedListNode tail;                  // 尾节点
    int capacity;

    public LRUCache(int capacity) {       //构造函数，初始化双向链表
        head =new DoubleLinkedListNode(0,0);  //  next指针指向firstNode
        tail =new DoubleLinkedListNode(0,0);  //  pre指针指向LastNode
        head.next =tail;
        tail.pre  =head;
        this.capacity=capacity;
        map =new HashMap<>();
    }
    
    public int get(int key) {
        if(map.containsKey(key)){
            DoubleLinkedListNode node = map.get(key);  //构造一个值为key的node
            delete(node);                       //删掉该node
            add(node);                          //再从头部添加node，map中也要添加
            return node.val;
        }else{
            return -1;
        }
    }

      public void put(int key, int value) {
          if(map.containsKey(key)){
              DoubleLinkedListNode node1 = map.get(key);
              delete(node1);
              node1.val =value;  // 很重要！！！！ 替换原来的值
              add(node1);
          }else{
              DoubleLinkedListNode newnode = new DoubleLinkedListNode(key,value);
              add(newnode);
          }

    }
    public void delete(DoubleLinkedListNode node){
        DoubleLinkedListNode pre = node.pre;
        DoubleLinkedListNode next= node.next;
        pre.next=next;
        next.pre=pre;
    }

    public void add(DoubleLinkedListNode node){
        insert(node);            // 在链表的头部添加
        map.put(node.key,node);  // 向map添加 key
        if(map.size()>capacity){  //判断是否map容量溢出
            DoubleLinkedListNode toBedelete = tail.pre; //找到最后一个节点
            delete(toBedelete);                 // 删除掉
            map.remove(toBedelete.key);        // map中也要删除掉

        }
    }

    public void insert(DoubleLinkedListNode node){
        DoubleLinkedListNode oldnode = head.next;
        head.next=node;
        oldnode.pre= node;
        node.next=oldnode;
        node.pre=head;
    }
    
  
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

自己写的笔记总结：