设计LRU缓存结构

题目描述

设计LRU缓存结构，该结构在构造时确定大小，假设大小为K，并有如下两个功能
set(key, value)：将记录(key, value)插入该结构
get(key)：返回key对应的value值
[要求]
set和get方法的时间复杂度为O(1)
某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。
当缓存的大小超过K时，移除最不经常使用的记录，即set或get最久远的。
若opt=1，接下来两个整数x, y，表示set(x, y)
若opt=2，接下来一个整数x，表示get(x)，若x未出现过或已被移除，则返回-1
对于每个操作2，输出一个答案
示例1
输入
复制
[[1,1,1],[1,2,2],[1,3,2],[2,1],[1,4,4],[2,2]],3
返回值
复制
[1,-1]
说明
第一次操作后：最常使用的记录为(“1”, 1)
第二次操作后：最常使用的记录为(“2”, 2)，(“1”, 1)变为最不常用的
第三次操作后：最常使用的记录为(“3”, 2)，(“1”, 1)还是最不常用的
第四次操作后：最常用的记录为(“1”, 1)，(“2”, 2)变为最不常用的
第五次操作后：大小超过了3，所以移除此时最不常使用的记录(“2”, 2)，加入记录(“4”, 4)，并且为最常使用的记录，然后(“3”, 2)变为最不常使用的记录

思路

• LRU概述

LRU 是 Least Recently Used 的缩写，译为最近最少使用。它的理论基础为“最近使用的数据会在未来一段时期内仍然被使用，已经很久没有使用的数据大概率在未来很长一段时间仍然不会被使用”由于该思想非常契合业务场景 ，并且可以解决很多实际开发中的问题，所以我们经常通过 LRU 的思想来作缓存，一般也将其称为LRU缓存机制。

• 实现原理

1. 双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的。
2. 哈希表即为普通的哈希映射（HashMap），通过缓存数据的键映射到其在双向链表中的位置。

• 流程

1. get()

• key不存在就返回-1
• key存在，key对应·的节点就是最近被使用的节点,哈希表定位该节点在双向链表中的位置并删除同时移到链表头(题目要求就是某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。)

2. set()

key不存在创建一个新节点,头插法插入链表头部,并插入哈希表；同时判断当前链表大小是否超出祖达容量，如果超出最大容量删除尾部节点及对应好戏表值( 当缓存的大小超过K时，移除最不经常使用的记录，即set或get最久远的。 )
key存在更新节点的值即可

• 代码

import java.util.*;


public class Solution {
    /**
     * lru design
     * @param operators int整型二维数组 the ops
     * @param k int整型 the k
     * @return int整型一维数组
     */
    public int[] LRU (int[][] operators, int k) {
        LRUCache cache=new LRUCache(k);
        List<Integer> record=new ArrayList<>();
        for(int[] each:operators){
            //第一个元素是操作符
            int operation=each[0];
            if(operation==1){
                cache.set(each[1],each[2]);
            }else{
                record.add(cache.get(each[1]));
            }
        }
        
        int length=record.size();
        int[] res=new int[length];
        for(int i=0;i<length;i++){
            res[i]=record.get(i);
        }
        return res;
        //这个API只能只能用于返回Object的
        //record.toArray(new int[record.size()]);
        
    }
    
}
class LRUCache{
    //双向环链表
    class DoubleLinkedNode{
         int key,val;
         DoubleLinkedNode pre,next;
         public DoubleLinkedNode(int key,int val){
             this.key=key;
             this.val=val;
         }
     }
    
    DoubleLinkedNode dummyHead,dummyTail;
    //HashMap映射使set和get方法的时间复杂度为O(1)
    Map<Integer,DoubleLinkedNode> map;
    //当前链表打下
    int size;
    //链表最大容量
    int capacity;
    
    public LRUCache(int capacity){
        this.capacity=capacity;
        map=new HashMap<>();
        //傀儡节点
        dummyTail=new DoubleLinkedNode(-1,-1);
        dummyHead=new DoubleLinkedNode(-1,-1);
        //构造双向链表
        dummyHead.next=dummyTail;
        dummyTail.pre=dummyHead;
        size=0;
    }
    
    //删除指定节点
    private void removeNode(DoubleLinkedNode node){
        node.pre.next=node.next;
        node.next.pre=node.pre;
    }
    
    //头插法：头就是最近最少使用
    private void addToHead(DoubleLinkedNode node){
        node.next=dummyHead.next;
        node.pre=dummyHead;
        
        dummyHead.next.pre=node;
        dummyHead.next=node;
    }
    
    //移到双链表头部
    private void moveToHead(DoubleLinkedNode node){
        removeNode(node);
        addToHead(node);
    }
    //尾删法
    private DoubleLinkedNode removeLast(){
        DoubleLinkedNode lastNode=dummyTail.pre;
        removeNode(lastNode);
        
        return lastNode;
    }
    
    //获取元素
    public int get(int key){
        DoubleLinkedNode node=map.get(key);
        if(node==null){
            return -1;
        }
        
        //某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。移到双向链表头部
        moveToHead(node);
        return node.val;
    }
    
    
    //插入元素
    public void set(int key,int val){
        DoubleLinkedNode node=map.get(key);
        if(node!=null){
            //节点存在更新值即可
            node.val=val;
            //要求某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。
            moveToHead(node);
        }else{
            //节点不存在则插入
            node=new DoubleLinkedNode(key,val);
            map.put(key,node);
            //某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。移到双向链表
            addToHead(node);
            size++;
            if(size>capacity){
                //当缓存的大小超过K时，移除最不经常使用的记录，即set或get最久远的。
                DoubleLinkedNode tail=removeLast();
                map.remove(tail.key);
                //当前链表大小减1
                size--;
            }
        }
    }
    
    
}