LeetCode Day13 | 239. 滑动窗口最大值、347. 前 K 个高频元素

239. 滑动窗口最大值

难度：☆5

单调队列。具体来说是单调递减队列，它适合本题是因为它保证了（1）队列元素递减，（2）弹出的元素在队首或已经被弹出。

思路：队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素是由大到小的。

设计单调队列的时候，pop 和 push 操作要保持如下规则：

1. pop(value)：如果滑动窗口移除的元素 value 等于单调队列的出口（队首）的元素，那么队列弹出元素，否则不用任何操作；
2. push(value)：如果滑动窗口新增的元素 value 大于单调队列的入口（队尾）的元素，那么就将队列入口（队尾）的元素弹出，直到 push 的元素小于等于队列入口（队尾）的元素为止。

保持如上规则，每次窗口移动的时候，只要调用 queue.front() 就可以返回当前窗口的最大值。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        Deque<Integer> deque = new ArrayDeque<>(); // 用一个Deque类型的单调递减队列来存储索引
        int n = nums.length;
        int[] result = 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.peekFirst() < i - k + 1) {
                deque.pollFirst();
            }
            // 2.既然是单调递减，如果当前队尾比进入队尾的数小，则弹出当前队尾
            while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
                deque.pollLast();
            }
            deque.offerLast(i);
            if (i >= k - 1) { // 当i增长到符合第一个滑动窗口k范围时，每滑动一步都将队首元素放入结果
                result[idx++] = nums[deque.peekFirst()];
            }
        }
        return result;
    }
}

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

347. 前 K 个高频元素

难度：☆5

优先级队列，小顶堆，映射。本题涉及到三项任务：

1. 统计元素出现的次数——使用map映射来统计。
2. 对次数排序——使用优先级队列来排序。
3. 找出前k个高频元素——使用小顶堆比大顶堆更快。因为大顶堆需要对所有元素进行排序，而小顶堆只需要维持k个元素有序。

本题用小顶堆，因为要统计出现次数最多的前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个出现次数最多的元素。

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer, Integer> map = new HashMap<>(); // key为数组元素值,val为对应的出现次数
        for (int num : nums) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        // 在优先级队列中存储二元组(num, cnt),cnt表示元素值,num表示在数组中出现的次数
        // 出现的次数按从队首到队尾的顺序,从小到大排,出现次数最低的在队首(相当于小顶堆)
        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair1[1] - pair2[1]);
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) { // 小顶堆只需要维持k个元素有序
            if (pq.size() < k) { // 小顶堆的元素个数小于k个时直接加
                pq.add(new int[] { entry.getKey(), entry.getValue() });
            } else if (entry.getValue() > pq.peek()[1]) { // 当前元素出现次数大于小顶堆的根节点
                pq.poll(); // 弹出队首(小顶堆的根节点),即删除堆里出现次数最少的,剩下就是出现次数多的
                pq.add(new int[] { entry.getKey(), entry.getValue() });
            }
        }
        int[] ans = new int[k];
        for (int i = k - 1; i >= 0; i--) { // 依次弹出小顶堆,先弹出的出现次数少,后弹出的出现次数多
            ans[i] = pq.poll()[0];
        }
        return ans;
    }
}

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