【牛客】设计LRU缓存结构

题目描述

设计LRU缓存结构，该结构在构造时确定大小，假设大小为K，并有如下两个功能

• set(key, value)：将记录(key, value)插入该结构
• get(key)：返回key对应的value值

要求

1. set和get方法的时间复杂度为O(1)
2. 某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。
3. 当缓存的大小超过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)变为最不常使用的记录

package test;
import java.util.*;


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
        ArrayList<Integer> list = new ArrayList<>();
        LRUCache lru = new LRUCache(k);
        for(int[] opt:operators){
            if(opt[0] == 1){
                lru.put(opt[1],opt[2]);
            }else{
                list.add(lru.get(opt[1]));
            }
        }
        int[] res = new int[list.size()];
        int i = 0;
        for(int val:list){
            res[i] = list.get(i);
            i++;
        }
        return res;
    }
}

//设置LRU缓存结构
class LRUCache{
    int cap;
    LinkedHashMap<Integer, Integer> cache = new LinkedHashMap<>();

    public LRUCache(int capactity){
        this.cap = capactity;
    }

    // 将key变为最近使用
    private void makeRecently(int key){
        int val = cache.get(key);
        //删除key，重新插入到队尾
        cache.remove(key);
        cache.put(key, val);
    }


    //获取值
    public int get(int key){
        if(!cache.containsKey(key)){
            return -1;
        }
        //将这个key变为最近使用的
        makeRecently(key);
        return cache.get(key);
    }

    //存进值
    public void put(int key,int val){
        if(cache.containsKey(key)){
            cache.put(key, val);
            //设置为最近使用
            makeRecently(key);
            return;
        }

        //超出缓存的大小
        if(cache.size() >= this.cap){
            //拿到链表头部的key（其最久未使用的key）
            int oldstKet = cache.keySet().iterator().next();
            cache.remove(oldstKet);
        }
        //将新的key添加到链表尾部
        cache.put(key,val);
    }
}
public class Main {
    public static void main(String[] args) {
        Solution s = new Solution();
        int[][] t = new int[][]{{1,1,1},{1,2,2},{1,3,2},{2,1},{1,4,4},{2,2}};
        int[] in = s.LRU(t,3);
        System.out.print("[");
        for (int i = 0; i < in.length; i++) {
            if (i != in.length - 1) {
                System.out.print(in[i] + ",");
            } else {
                System.out.println(in[i] + "]");
            }
        }
    }
}