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

239. 滑动窗口最大值

题目链接：https://leetcode.cn/problems/sliding-window-maximum/

题目要求：

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

返回滑动窗口中的最大值。

进阶：

你能在线性时间复杂度内解决此题吗？

提示：

• 1 <= nums.length <= 10^5

• -10^4 <= nums[i] <= 10^4

• 1 <= k <= nums.length

总结：本题非常巧妙，定义一个单调递减的队列，要保证进来的元素，始终队头是最大的一个元素，我们不需要记录滑动窗口里每个值，每个大值前面的小数不需要记录，每次入队，队尾元素小于进队元素，就弄出，不记录，当队列中队头的元素从滑动窗口中出来的时候才需要弹出，不记录的小元素从窗口出来时，因为没有记录所以也没事。第一轮大概了解即可，仔细看代码即可看懂。

//自己定义一个单调递减队列，保证每次队列头为当前滑动窗口最大元素
class MyQueue{
    Deque<Integer> deq = new LinkedList<>();
    void poll(int val){
        //如果弹出值为目前单调递减序列中的最大值，说明该最大值已经出滑动窗口需要弹出
        if(!deq.isEmpty() && val == deq.peek()){
            deq.poll();
        }
    }
    void add(int val){
        //如果进窗口的新元素比他前面一个的大，则小的不用维护，直接弹出，保证队列peek永远为当前窗口最大值
        while(!deq.isEmpty() && val > deq.getLast()){
            deq.removeLast();
        }
        deq.add(val);
    }
    int peek(){
        return deq.peek();
    }
}
class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length == 1){
            return nums;
        }
        int len = nums.length - k + 1;
        //创建一个结果数组
        int[] res = new int[len];
        int num = 0;
        //自定义队列
        MyQueue myqueue = new MyQueue();
        //先将第一个窗口所有元素入队
        for(int i = 0;i < k;i++){
            myqueue.add(nums[i]);
        }
        //此时队列的第一个元素即为第一个窗口的最大值，需要给到结果数组中去
        res[num++] = myqueue.peek();
        //滑动窗口依次向后移动
        for(int i = k;i < nums.length;i++){
            //需要先弹出窗口最前面的元素，再将新加入窗口元素入队
            //这里实际最大值前面的小值，早就弹出过了，不在单调递减队列中，只需要看当前弹出的元素是否为当前窗口的最大值，也就是队列的peek，如果是，则真的要弹出了
            myqueue.poll(nums[i - k]);
            myqueue.add(nums[i]);
            //此时是新的窗口，弹出元素又加入元素了，确定了新窗口的新的最大值
            res[num++] = myqueue.peek();
        }
        return res;
    }
}

347.前 K 个高频元素

题目链接：https://leetcode.cn/problems/top-k-frequent-elements/

题目要求：

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

示例 1:

• 输入: nums = [1,1,1,2,2,3], k = 2

• 输出: [1,2]

示例 2:

• 输入: nums = [1], k = 1

• 输出: [1]

提示：

• 你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。

• 你的算法的时间复杂度必须优于 $O(n \log n)$ , n 是数组的大小。

• 题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。

• 你可以按任意顺序返回答案。

总结：因为要返回频率最高的元素，本题首先想到用map数据结构，key存元素值，value存出现次数，但是还需要排序，选出value值最高的元素，故想到小根堆，nlogk复杂度,适合集合n很多的时候选出很少的最大的k个元素时的情况，优于nlogn，一刷熟悉即可，仔细阅读代码细细体会。

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        //定义一个哈希表，key为元素值，value为元素出现个数
        Map<Integer,Integer> map = new HashMap<>();
        for(int num : nums){
            //该方法如果哈希表中有该值的key，则返回value，无则返回第二个参数，自己设置的值
            map.put(num,map.getOrDefault(num,0) + 1);
        }
        //优先队列存储二元组（num,cnt）cnt表示num数值出现的次数
        //要得出最大的前k个元素，则需要使用小根堆，小根堆的根的值是小于两边叉的值，根值最小，最先弹出，故最后剩下的就为最大的，而且顺序是从小到大的。
        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1,pair2) -> pair1[1] - pair2[1]);
        //将存储在map中的每个值以及出现的次数，根据次数用小根堆来选出次数最多的几个值
        //entryset为列出map中每个键值对的值
        for(Map.Entry<Integer,Integer> entry : map.entrySet()){
            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()});
                }
            }
        }
        //遍历结束，得出最终小根堆,根元素为k个元素里出现次数最少的
        int[] res = new int[k];
        for(int i = k-1;i >= 0;i--){
            res[i] = pq.poll()[0];
        }
        return res;
    }
}