代码随想录算法训练营第十三天 | 239. 滑动窗口最大值、347.前 K 个高频元素、栈和队列总结

代码随想录算法训练营第十三天 | 239. 滑动窗口最大值、347.前 K 个高频元素、栈和队列总结

239. 滑动窗口最大值

题目链接：239. 滑动窗口最大值

自定义单调队列

思路：暴力方法，遍历一遍的过程中每次从窗口中再找到最大的数值，这样很明显是O(n × k)的算法。优化的想法为——一个队列先放进去窗口里的元素，然后随着窗口的移动，队列也一进一出；每次移动之后，队列返回其中的最大值。再分析一下，队列里的元素一定是要排序的，而且要最大值放在出队口，这样每次移动后查看队列出口就知道最大值是多少了。但如果把窗口里的元素都放进队列里，窗口移动的时候，队列需要弹出元素。那么已经排序之后的队列怎么能把窗口要移除的元素（这个元素不一定是最大值）弹出呢？

对于本题而言，队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。 那么这个维护元素单调递减的队列就叫做单调队列，即单调递减或单调递增的队列。

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

1. pop(value)：如果窗口移除的元素 value 等于单调队列的出口元素，那么弹出出口处的元素，否则不进行任何操作；
2. push(value)：如果即将 push 的元素 value 大于入口元素的数值，那么就将队列入口的元素弹出，直到 push 元素的数值小于等于队列入口元素的数值为止。（这一步保证队列单调递减）

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

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
    	// 剪枝 
        if (nums.length == 1) {
            return nums;
        }
        // 记录返回数组的长度
        int len = nums.length - k + 1;
        int[] result = new int[len];
        MyQueue deque = new MyQueue();
        int order = 0; // 用于向返回数组添加元素
        // 先向队列加入初始的 k 个值
        for (int i = 0; i < k; i++) {
            deque.add(nums[i]);
        }
        // 将初始的 k 个值中的最大值加入返回数组
        result[order++] = deque.peek();
        // 模拟窗口的向后移动
        for (int i = k; i < nums.length; i++) {
        	// 移除滑动窗口最前方的元素，是否真的移除由 poll() 函数判断
            deque.poll(nums[i - k]);
            // 将当前元素加入队列
            deque.add(nums[i]);
            // 返回当前窗口中的最大值，即队列出口处的元素
            result[order++] = deque.peek();
        }
        return result;
    }
}

class MyQueue {
    // 自定义数组实现单调队列
    Deque<Integer> deque = new LinkedList<>();

    // 弹出元素时，比较当前要弹出的数值是否等于队列出口的数值，
    // 如果相等且队列不为空，则弹出
    void poll(int val) {
        if (!deque.isEmpty() && val == deque.peek()) {
            deque.poll();
        }
    }
    //添加元素时，如果要添加的元素大于队列入口处的元素，就将入口元素弹出
    //以此保证队列元素单调递减
    //比如此时队列元素为 3,1，而 2 将要入队，比 1 大，所以 1 弹出，此时队列为 3,2。
    void add(int val) {
        while (!deque.isEmpty() && val > deque.getLast()) {
            deque.removeLast();
        }
        deque.add(val);
    }
    // 返回队列出口元素，即窗口内的最大值
    int peek() {
        return deque.peek();
    }
}

时间复杂度：O(n)——容易认为队列在 push元素的过程中还有pop操作，不是纯粹的O(n)。其实观察一下单调队列的实现，nums 中的每个元素最多只会被 push 和 pop 各一次，没有任何多余操作，所以整体的复杂度还是 O(n)。

空间复杂度：O(k)——因为定义了一个辅助队列。

347.前 K 个高频元素

题目链接：347.前 K 个高频元素

优先级队列（大、小顶堆）

思路：本题的解答主要包含以下三个内容：

1. 统计各元素的出现频率；
2. 对频率排序；
3. 找出前 K 个高频元素；

对第 1 步可以使用 map 来进行统计；
对第 2 步可以使用一种容器适配器——优先级队列，即一个披着队列外衣的堆。因为优先级队列对外接口只有两个：从队头取元素和从队尾添加元素。再无其他取元素的方式，因此看起来就是一个队列。堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆，小于等于左右孩子就是小顶堆。本题使用优先级队列来对部分频率进行排序。倘若使用快排，则要将 map 转换为数组，然后对整个数组进行排序。 而对于本题，其实只需要维护 k 个有序的序列就可以了，所以使用优先级队列是最优的。

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

寻找前 k 个最大元素流程如图所示：（图中的频率只有三个，所以正好构成一个大小为3的小顶堆，如果频率更多一些，则用这个小顶堆进行扫描）
简化版代码：

class Solution {
    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]; // 结果集
        // 记录元素出现次数
        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);
            if(pq.size() > k) {
                pq.poll();
            }
        }
        // 因为小顶堆先弹出的是出现频率最小的，所以倒序输出到结果集
        for(int i = k - 1; i >= 0; i--) {
            res[i] = pq.poll()[0]; // 获取优先队列里的元素
        }
        return res;
    }
}

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

代码随想录提供的基于大顶堆和小顶堆的 Java 实现：

/*Comparator接口说明:
 * 返回负数，形参中第一个参数排在前面；返回正数，形参中第二个参数排在前面
 * 对于队列：排在前面意味着往队头靠
 * 对于堆（使用PriorityQueue实现）：从队头到队尾按从小到大排就是最小堆（小顶堆），
 *                                从队头到队尾按从大到小排就是最大堆（大顶堆）--->队头元素相当于堆的根节点
 * */
class Solution {
    //解法1：基于大顶堆实现
    public int[] topKFrequent1(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)->pair2[1]-pair1[1]);
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){//大顶堆需要对所有元素进行排序
            pq.add(new int[]{entry.getKey(),entry.getValue()});
        }
        int[] ans = new int[k];
        for(int i=0;i<k;i++){//依次从队头弹出k个,就是出现频率前k高的元素
            ans[i] = pq.poll()[0];
        }
        return ans;
    }
    //解法2：基于小顶堆实现
    public int[] topKFrequent2(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]){//当前元素出现次数大于小顶堆的根结点(这k个元素中出现次数最少的那个)
                    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;
    }
}

栈和队列总结

栈和队列的总结：代码随想录—栈与队列总结篇