Day12 滑动窗口最大值+前 K 个高频元素

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

344.反转字符串

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

示例 1：
输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置 最大值

---

[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7

示例 2：
输入：nums = [1], k = 1
输出：[1]

思路：

来自于LeetCode题解
在滑动窗口形成及移动的过程中，元素是从窗口的右侧进入的，然后由于窗口大小是固定的，因此多余的元素是从窗口左侧移除的。 一端进入，另一端移除，可以借助队列来求解。
题目要求是返回每个窗口中的最大值，开始分析。
左右指针都从0开始。

1. 首先队列为空的时候，right指向的位置加到队列
2. right指针考察的元素小于队尾元素时，要入队，目的是为了观察其是否是下一个窗口的最大值。这个时候队列会有一个特征，始终保持递减。
3. right指针考察的元素大于等于队尾元素时，就要把队列中所有小于该元素的值全部踢出去后（while实现，不要忘记队列不能为空），再入队，和前面一样，始终保持队列递减。
4. 还要判断队首元素的下标不能小于滑动窗口的左边界left，这时队首元素已经出了滑动窗口范围，因此将其从队首移除。
5. 当right指针移动到比left大k-1的时候，此时[left，right]包含了k个元素，滑动窗口形成，返回队首元素（也就是最大值）。之后left跟随right每次加1，始终保持滑动窗口。[注意：这边只做返回该窗口最大值的一个操作，不能做把这个队首元素踢出去，因为此时队首元素不一定小于left]
6. 队列中存index，方便比较。

代码部分：

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        Deque<Integer> queue = new LinkedList<>();
        int[] ans = new int[nums.length - k + 1];         // 窗口个数
        int left = 0;
        // 注意三个逻辑块的顺序

		// 如果队列不为空且当前考察元素大于等于队尾元素，则将队尾元素移除。
        // 直到，队列为空或当前考察元素小于新的队尾元素
        for(int right = 0; right <nums.length; right++){
            while(!queue.isEmpty() && nums[right] >= nums[queue.peekLast()]){
                // 队列是单调递减的，这样巧妙的（省去比较步骤）把小于当前考察元素的值全部从队列中踢出去
                queue.removeLast();
            }
			// 存储元素下标
            queue.addLast(right);
			// 当队首元素的下标小于滑动窗口左侧边界left时
            // 表示队首元素已经不再滑动窗口内，因此将其从队首移除
            if(queue.peekFirst() < left){
                queue.removeFirst();
            }
            if(right - left == k - 1){
                ans[left] = nums[queue.peekFirst()];
                left++;
            }
        }
        return ans;
    }
}

第二种写法：

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        Deque<Integer> queue = new LinkedList<>();
        int[] ans = new int[nums.length - k + 1];         // 窗口个数
        // 注意三个逻辑块的顺序

		// 如果队列不为空且当前考察元素大于等于队尾元素，则将队尾元素移除。
        // 直到，队列为空或当前考察元素小于新的队尾元素
        for(int right = 0; right <nums.length; right++){
            while(!queue.isEmpty() && nums[right] >= nums[queue.peekLast()]){
                // 队列是单调递减的，这样巧妙的（省去比较步骤）把小于当前考察元素的值全部从队列中踢出去
                queue.removeLast();
            }
			// 存储元素下标
            queue.addLast(right);
			// 计算窗口左侧边界
			int left = right - k +1;
			// 当队首元素的下标小于滑动窗口左侧边界left时
            // 表示队首元素已经不再滑动窗口内，因此将其从队首移除
            if(queue.peekFirst() < left){
                queue.removeFirst();
            }
            // 由于数组下标从0开始，因此当窗口右边界right+1大于等于窗口大小k时
            // 意味着窗口形成。此时，队首元素就是该窗口内的最大值
            if (right +1 >= k) {
                res[left] = nums[queue.peekFirst()];
            }
        }
        return ans;
    }
}

347. 前 K 个高频元素

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

示例 1:
输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

示例 2:
输入: nums = [1], k = 1
输出: [1]

思路：

这道题主要实现三个功能：

1. 要统计元素出现频率
   实现方法：用map来统计出现频率。

2. 对频率排序
   实现方法：PriorityQueue（优先级队列是一个表面队列的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列。而且优先级队列内部元素是自动依照元素的权值排列）

3. 找出前K个高频元素
   堆的解释：是一个完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。所以有两种，父亲结点大于等于左右孩子就是大顶堆（堆头是最大元素），父亲结点小于等于左右孩子就是小顶堆（堆头是最小元素）。
   用哪个呢，题目要前k个高频元素，如果定义一个size为k的大顶堆，在每次更新大顶推的时候，把最大的弹出来，所以要对所有元素排序，保留前k个。逆向思维，如果使用小顶堆，小顶堆每次把最小的弹出去，所以size为k的小顶堆里面剩下的就是我们想要的最大的k个元素。
   ![[Pasted image 20230523000912.png]]

代码部分：

基于小顶堆实现：

/*Comparator接口说明:
 * 返回负数，形参中第一个参数排在前面；返回正数，形参中第二个参数排在前面
 * 对于队列：排在前面意味着往队头靠
 * 对于堆（使用PriorityQueue实现）：从队头到队尾按从小到大排就是最小堆（小顶堆），
 *                                从队头到队尾按从大到小排就是最大堆（大顶堆）--->队头元素相当于堆的根节点
 * */
class Solution {
    public int[] topKFrequent(int[] nums, int k) {
		//key为数组元素值,val为对应出现次数
        HashMap<Integer, Integer> map = new HashMap<>();
        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()){
            if(pq.size() < k){   //小顶堆元素个数小于k个时直接加
                pq.add(new int[]{entry.getKey(), entry.getValue()});
            }else{
		//当前元素出现次数大于小顶堆的根结点(这k个元素中出现次数最少的那个)
                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;
    }
}

基于大顶堆实现：

class Solution {
    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;
    }
}