239. 滑动窗口最大值

文字讲解：滑动窗口最大值

视频讲解：单调队列正式登场！

题设：给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。返回 滑动窗口中的最大值 。

难点：单调队列的原理。

public int[] maxSlidingWindow(int[] nums, int k) {
    ArrayDeque<Integer> deque = new ArrayDeque<>();
    int n = nums.length;
    int[] res = new int[n - k + 1];
    int idx = 0;
    for (int i = 0; i < n; i++) {
        // 根据题意，i为nums下标，是要在[i - k + 1, i] 中选到最大值，只需要保证两点
        // 1.队列头结点需要在[i - k + 1, i]范围内，不符合则要弹出
        while (!deque.isEmpty() && deque.peek() < i - k + 1) {
            deque.poll();
        }
        // 2.既然是单调，就要保证每次放进去的数字要比末尾的都大，否则也弹出
        while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
            deque.pollLast();
        }

        deque.offer(i);

        // 因为单调，当i增长到符合第一个k范围的时候，每滑动一步都将队列头节点放入结果就行了
        if (i >= k - 1) {
            res[idx++] = nums[deque.peek()];
        }
    }
    return res;
}

复杂度分析：

• 时间复杂度: O(n)。
• 空间复杂度: O(k)。

347.前 K 个高频元素

文字讲解：前 K 个高频元素

视频讲解：优先级队列正式登场！

题设：给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

难点：优先级队列的原理。

public int[] topKFrequent(int[] nums, int k) {
// 优先级队列，为了避免复杂 api 操作，pq 存储数组
            // lambda 表达式设置优先级队列从大到小存储 o1 - o2 为从小到大，o2 - o1 反之
            PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> o1[1] - o2[1]);
            int[] res = new int[k]; // 答案数组为 k 个元素
            Map<Integer, Integer> map = new HashMap<>(); // 记录元素出现次数
            for (int num : nums) map.put(num, map.getOrDefault(num, 0) + 1);
            for (var x : map.entrySet()) { // entrySet 获取 k-v Set 集合
                // 将 kv 转化成数组
                int[] tmp = new int[2];
                tmp[0] = x.getKey();
                tmp[1] = x.getValue();
                pq.offer(tmp);
                // 下面的代码是根据小根堆实现的，我只保留优先队列的最后的k个，只要超出了k我就将最小的弹出，剩余的k个就是答案
                if (pq.size() > k) {
                    pq.poll();
                }
            }
            for (int i = 0; i < k; i++) {
                res[i] = pq.poll()[0]; // 获取优先队列里的元素
            }
            return res;
        }

复杂度分析：

• 时间复杂度: O(nlogk)。
• 空间复杂度: O(n)。