题目描述
设计LRU(最近最少使用)缓存结构,该结构在构造时确定大小,假设大小为K,并有如下两个功能
- set(key, value):将记录(key, value)插入该结构
- get(key):返回key对应的value值
提示:
1.某个key的set或get操作一旦发生,认为这个key的记录成了最常使用的,然后都会刷新缓存。
2.当缓存的大小超过K时,移除最不经常使用的记录。
3.输入一个二维数组与K,二维数组每一维有2个或者3个数字,第1个数字为opt,第2,3个数字为key,value
若opt=1,接下来两个整数key, value,表示set(key, value)
若opt=2,接下来一个整数key,表示get(key),若key未出现过或已被移除,则返回-1
对于每个opt=2,输出一个答案
4.为了方便区分缓存里key与value,下面说明的缓存里key用""号包裹
进阶:你是否可以在O(1)的时间复杂度完成set和get操作
示例1
输入: [[1,1,1],[1,2,2],[2,1],[1,3,3],[2,2],[1,4,4],[2,1],[2,3],[2,4]],2
复制 返回值: [1,-1,-1,3,4]
示例2
输入: [[1,1,1],[1,2,2],[1,3,2],[2,1],[1,4,4],[2,2]],3 复制 返回值: [1,-1] 复制
说明: [1,1,1],第一个1表示opt=1,要set(1,1),即将(1,1)插入缓存,缓存是{“1”=1}
[1,2,2],第一个1表示opt=1,要set(2,2),即将(2,2)插入缓存,缓存是{“1”=1,“2”=2}
[1,3,2],第一个1表示opt=1,要set(3,2),即将(3,2)插入缓存,缓存是{“1”=1,“2”=2,“3”=2}
[2,1],第一个2表示opt=2,要get(1),返回是[1],因为get(1)操作,缓存更新,缓存是{“2”=2,“3”=2,“1”=1}
[1,4,4],第一个1表示opt=1,要set(4,4),即将(4,4)插入缓存,但是缓存已经达到最大容量3,移除最不经常使用的{“2”=2},插入{“4”=4},缓存是{“3”=2,“1”=1,“4”=4}
[2,2],第一个2表示opt=2,要get(2),查找不到,返回是[1,-1]
解题思路
首先要实现这个set和get方法,和Map类似,利用set来设置键值对,key:value,key不能重复,后面如果输入已有的key,会将原来的覆盖,题中,K代表这个这个缓存大小,当数据超过这个值,时间长不用的数据就会被抛弃,也就是说,最先进去且不更新的数据会被抛弃,符合队列的特点,本人利用两个队列来实现LRU缓存结构,队列中存放的是链表,0和1分别代表使用set添加进来的key和value,利用map来计数,记录输出的key在输入时被更改了几次,以最新的一次为准,让其他就得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) {
// write code here
Queue<List<Integer>> queue1 = new LinkedList<>();//就绪队列
Queue<List<Integer>> queue2 = new LinkedList<>();//辅助队列
List<Integer> r = new ArrayList<>();//记录输出信息
Map<Integer,Integer> map = new HashMap<>();//记录要输出的key被修改几次
for(int i = 0;i < operators.length;i++){
List<Integer> list1 = new ArrayList<>();
if(operators[i][0] == 1){//opt=1
list1.add(operators[i][1]);
if(!map.containsKey(operators[i][1])){
map.put(operators[i][1],1);
}else{
map.put(operators[i][1],map.get(operators[i][1]) + 1);
}
list1.add(operators[i][2]);
if(queue1.size() == k){
queue1.poll();
}
queue1.offer(list1);
}else{//opt=2
boolean flg = false;
while(!queue1.isEmpty()){
List<Integer> ret = queue1.peek();
int tmp = ret.get(0);
if(tmp != operators[i][1]){
queue2.offer(queue1.poll());
}else{
int count = map.get(tmp);//更新了几次,按最后一次算
flg = true;
while(!queue1.isEmpty()){
if(tmp == queue1.peek().get(0)){
if(count == 1){
r.add(queue1.peek().get(1));//将要输出的值存入r
ret = queue1.poll();
map.put(tmp,1);
}else{
count--;
queue1.poll();//就输入抛弃
}
}else{
queue2.offer(queue1.poll());
}
}
queue2.offer(ret);
}
}
if(flg == false){
r.add(-1);
}
//永远保持queue1为就绪队列
while(!queue2.isEmpty()){
queue1.offer(queue2.poll());
}
}
}
int[] arr = new int[r.size()];
for(int i = 0;i < r.size();i++){
arr[i] = r.get(i);
}
return arr;
}
}