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

 239. 滑动窗口最大值 （一刷至少需要理解思路）

之前讲的都是栈的应用，这次该是队列的应用了。

本题算比较有难度的，需要自己去构造单调队列，建议先看视频来理解。 

文章讲解/视频讲解：代码随想录

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

//解法一
//自定义数组
class MyQueue {
    Deque 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();
    }
}

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();
        //先将前k的元素放入队列
        for (int i = 0; i < k; i++) {
            myQueue.add(nums[i]);
        }
        res[num++] = myQueue.peek();
        for (int i = k; i < nums.length; i++) {
            //滑动窗口移除最前面的元素，移除是判断该元素是否放入队列
            myQueue.poll(nums[i - k]);
            //滑动窗口加入最后面的元素
            myQueue.add(nums[i]);
            //记录对应的最大值
            res[num++] = myQueue.peek();
        }
        return res;
    }
}

其他题解：

遍历数组，将 数 存放在双向队列中，并用 L,R 来标记窗口的左边界和右边界。队列中保存的并不是真的 数，而是该数值对应的数组下标位置，并且数组中的数要从大到小排序。如果当前遍历的数比队尾的值大，则需要弹出队尾值，直到队列重新满足从大到小的要求。刚开始遍历时，L 和 R 都为 0，有一个形成窗口的过程，此过程没有最大值，L 不动，R 向右移。当窗口大小形成时，L 和 R 一起向右移，每次移动时，判断队首的值的数组下标是否在 [L,R] 中，如果不在则需要弹出队首的值，当前窗口的最大值即为队首的数。

输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7]

解释过程中队列中都是具体的值，方便理解，具体见代码。
初始状态：L=R=0,队列:{}
i=0,nums[0]=1。队列为空,直接加入。队列：{1}
i=1,nums[1]=3。队尾值为1，3>1，弹出队尾值，加入3。队列：{3}
i=2,nums[2]=-1。队尾值为3，-1<3，直接加入。队列：{3,-1}。此时窗口已经形成，L=0,R=2，result=[3]
i=3,nums[3]=-3。队尾值为-1，-3<-1，直接加入。队列：{3,-1,-3}。队首3对应的下标为1，L=1,R=3，有效。result=[3,3]
i=4,nums[4]=5。队尾值为-3，5>-3，依次弹出后加入。队列：{5}。此时L=2,R=4，有效。result=[3,3,5]
i=5,nums[5]=3。队尾值为5，3<5，直接加入。队列：{5,3}。此时L=3,R=5，有效。result=[3,3,5,5]
i=6,nums[6]=6。队尾值为3，6>3，依次弹出后加入。队列：{6}。此时L=4,R=6，有效。result=[3,3,5,5,6]
i=7,nums[7]=7。队尾值为6，7>6，弹出队尾值后加入。队列：{7}。此时L=5,R=7，有效。result=[3,3,5,5,6,7]

通过示例发现 R=i，L=k-R。由于队列中的值是从大到小排序的，所以每次窗口变动时，只需要判断队首的值是否还在窗口中就行了。
解释一下为什么队列中要存放数组下标的值而不是直接存储数值，因为要判断队首的值是否在窗口范围内，由数组下标取值很方便，而由值取数组下标不是很方便。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums == null || nums.length < 2) return nums;
        // 双向队列 保存当前窗口最大值的数组位置 保证队列中数组位置的数值按从大到小排序
        LinkedList queue = new LinkedList();
        // 结果数组
        int[] result = new int[nums.length-k+1];
        // 遍历nums数组
        for(int i = 0;i < nums.length;i++){
            // 保证从大到小 如果前面数小则需要依次弹出，直至满足要求
            while(!queue.isEmpty() && nums[queue.peekLast()] <= nums[i]){
                queue.pollLast();
            }
            // 添加当前值对应的数组下标
            queue.addLast(i);
            // 判断当前队列中队首的值是否有效
            if(queue.peek() <= i-k){
                queue.poll();   
            } 
            // 当窗口长度为k时 保存当前窗口中最大值
            if(i+1 >= k){
                result[i+1-k] = nums[queue.peek()];
            }
        }
        return result;
    }
}

 347.前 K 个高频元素  （一刷至少需要理解思路）

大/小顶堆的应用， 在C++中就是优先级队列 

本题是 大数据中取前k值 的经典思路，了解想法之后，不算难

文章讲解/视频讲解：代码随想录

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

    public int[] topKFrequent2(int[] nums, int k) {
        Map map = new HashMap<>();//key为数组元素值,val为对应出现次数
        for(int num:nums){
            map.put(num,map.getOrDefault(num,0)+1);
        }
        //在优先队列中存储二元组(num,cnt),cnt表示元素值num在数组中的出现次数
        //出现次数按从队头到队尾的顺序是从小到大排,出现次数最低的在队头(相当于小顶堆)
        PriorityQueue pq = new PriorityQueue<>((pair1,pair2)->pair1[1]-pair2[1]);
        for(Map.Entry entry:map.entrySet()){//小顶堆只需要维持k个元素有序
            if(pq.size()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;
    }
}

for(Map.Entry entry: map.entrySet())是Java中的一种循环语句，用于遍历Map中的键值对（key-value）。

在这个循环语句中，map.entrySet()返回的是一个包含了Map中所有键值对的Set集合，Set中的每一个元素都是一个Map.Entry类型的对象，其中Integer表示键的数据类型，第二个Integer表示值的数据类型。因此，在循环中，可以通过entry.getKey()和entry.getValue()方法获取到当前键值对中的键和值，并进行相应的操作。

例如，下面的代码使用了for(Map.Entry entry: map.entrySet())循环来遍历一个名为map的Map，输出其中所有键值对的键和值：

Map map = new HashMap<>();
// 添加一些键值对
map.put(1, 10);
map.put(2, 20);
map.put(3, 30);
// 使用for循环遍历Map中的键值对
for(Map.Entry entry: map.entrySet()){
    int key = entry.getKey();
    int value = entry.getValue();
    System.out.println("Key: " + key + ", Value: " + value);
}

结果：
Key: 1, Value: 10
Key: 2, Value: 20
Key: 3, Value: 30

PriorityQueue pq = new PriorityQueue<>((pair1, pair2) -> pair1[1] - pair2[1]) 是一行Java代码，用于创建一个基于优先级的队列。

在这行代码中，PriorityQueue pq 创建了一个元素类型为 int[] 的优先级队列（PriorityQueue）。int[] 表示整数数组类型。

new PriorityQueue<>((pair1, pair2) -> pair1[1] - pair2[1])是通过 lambda 表达式定义的比较函数。该比较函数用于确定队列中元素的优先级顺序。

lambda 表达式 (pair1, pair2) -> pair1[1] - pair2[1] 定义了一个匿名函数，它接受两个参数 pair1 和 pair2，并根据 pair1[1] - pair2[1] 的结果来比较两个元素的优先级。

• 如果 pair1[1] - pair2[1] 返回负值，则 pair1 的优先级高于 pair2。
• 如果 pair1[1] - pair2[1] 返回零，则 pair1 和 pair2 的优先级相同。
• 如果 pair1[1] - pair2[1] 返回正值，则 pair1 的优先级低于 pair2。

这样，在优先级队列中，每次从队头取出的元素都是具有最高优先级的元素。

例如，下面的代码演示了如何使用该语句创建一个基于优先级的队列，并向其中添加一些整数数组元素：

PriorityQueue pq = new PriorityQueue<>((pair1, pair2) -> pair1[1] - pair2[1]);

// 向队列中添加元素
pq.offer(new int[]{1, 10});
pq.offer(new int[]{2, 20});
pq.offer(new int[]{3, 5});

// 输出队列中的元素
while (!pq.isEmpty()) {
    int[] pair = pq.poll();
    System.out.println("Key: " + pair[0] + ", Value: " + pair[1]);
}
Key: 3, Value: 5
Key: 1, Value: 10
Key: 2, Value: 20