牛客-NC93-设计LRU缓存结构

方法一：HashMap + Queue（自己写的）

思路：定义一个HashMap用于存放键值对，定义一个Queue记录存放时的顺序，也可用于更新顺序，定义一个ArrayList存放返回值（后面需要将其转换成数组）。直接遍历二维数组operators：
（1）当操作为set，即operators[i][0] == 1时，作以下判断：<1> 当前Queue长度并没有超过k，那直接使用HashMap和Queue分别存值和顺序。<2> 当前Queue长度超过，那就需要移除最不常用的，调用Queue移除队头元素即可，并将其在HashMap中设置为不可访问的状态，将当前遍历值存入HashMap和Queue。
（2）当操作为get，即operators[i][0] == 2时，此时我们需要从HashMap中取值，分为两种情况，存在和不存在于HashMap，从而改变value取值，此时，当value不为-1时，我们需要更新当前key在Queue中的位置。
遍历完成后，调整为题目要求的返回类型即可。

import java.util.*;


public class Solution {
    /**
     * lru design
     * @param operators int整型二维数组 the ops
     * @param k int整型 the k
     * @return int整型一维数组
     */
    public static int[] LRU (int[][] operators, int k) {
        // write code here
        // 存放键值对
        HashMap<String, String> hash = new HashMap<>();
        Queue<String> queue = new LinkedList<>();
        int idx = 0;
        // 存放返回值
        ArrayList<Integer> res = new ArrayList<>();
        for (int i = 0; i < operators.length; i++) {
            int opt = operators[i][0]; // 操作
            if (opt == 1) { // set
                // 取值
                String key = operators[i][1] + "";
                String value = operators[i][2] + "";

                if (queue.size() <= k - 1) {
                    // 存值
                    hash.put(key, value);
                    // 存值(顺序)
                    queue.offer(key);
                } else {
                    // 移除最不常用的
                    String target = queue.poll();

                    hash.put(target, "-1"); // 设为不可访问
                    // 存值
                    hash.put(key, value);
                    queue.offer(key);
                }
            } else if (opt == 2) { // get
                // 取值
                String key = operators[i][1] + "";
                int value;
                if (hash.containsKey(key)) {
                    value = Integer.parseInt(hash.get(key));
                } else {
                    value = -1;
                }
                res.add(value);
                if (value != -1) {
                    // 重新存放该值
                    queue.remove(key);
                    queue.offer(key);
                }
            }

        }

        int[] ret = new int[res.size()];
        for (int j = 0; j < res.size(); j++) {
            ret[j] = res.get(j);
        }
        return ret;
    }
}

时间复杂度： O(N), 因为需要遍历一遍二维数组，但get和set是O(1)时间复杂度。
空间复杂度： O(operators.length), 因为我们使用到HashMap和Queue存放数据，最坏情况下，整个二维数组的操作全部都是set操作，此时，我们需要将operators.length个数据存进上述两个数据结构中。
总结：本题考频极高，该问题设计类，常要求采用O(1)的时间复杂度实现，类似地还有队列实现栈、栈实现队列，详情请看link。