刷题day11 239滑动窗口最大值、347前K个高频元素、总结

一、239滑动窗口最大值

这道题主要是明白滑动窗口要创建滑动的话那么就poll掉前面的，add进后面的

然后利用队列peek()值来维护滑动窗口的每次滑动的最大值

再创建一个数组来专门保存每次最大值的结果

以上三点是需要注意的，然后就是他们的界值范围

结果数组保存的数组大小是len = nums.length - k + 1,因为如果k是3，他滑动到最后三个的时候就会停止，所以数组大小是len

然后是第一个for循环是想让队列里一开始存一个最大值，方便后续的函数方法的操作，注意这里res[num++] = queue.peek()的使用

最后就是维护队列最大值的过程，也就是说出队和入队的过程，出队的时候其实就是看出的元素是否是等于队列顶部的值，这里其实是有的位置已经在滑动窗口移动的时候已经空了，因为在add方法的逻辑比较的时候已经去掉前一个位置的值小于他后面的了，所以其实每次窗口滑动的时候就要判断一下是否peek的值要和要出去的值相等，相等的话说明这个最大值是在滑动窗口的最左边的位置(每次维护的时候进入队列最左边的值就是最大的值，也就是peek的值，这里滑动窗口和队列是两个东西，不要搞混了)，因为在下边入队的过程中已经是把那些小于顶部(每次滑动窗口最大值)的去掉了，当然还要再判断队列是不是空队列，不是空队列才可以执行。这里还要注意入队的时候，因为是从后边入队的，所以要调用的是队列的getLast()方法来比较，这里还要写作while的操作，如果值没有入队的值大，那么就给他移除掉，这里用到一个自带的removeLast()的函数来移除。

然后就是在主程序第二个for循环中i从0开始的话，那么i一直要循环到nums.length - k，然后poll(nums[i])，add(nums[i+k])，最后保存队列的最大值，res[num++] = queue.peek()

代码如下：

class MyQue{
    Deque<Integer> deque = new LinkedList<>();
    void poll(int val){
        if(!deque.isEmpty() && deque.peek() == val){
            deque.poll();
        }
    }

    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) {
        int len = nums.length - k + 1;
        int[] res = new int[len];
        int num = 0;                //数组下标从0开始

        MyQue queue = new MyQue();
        
        if(nums.length == 1){       //数组只有一个元素，那么就直接返回滑动窗口的最大值，就是它本身
            return nums;
        }
         
        
        for(int i=0;i<k;i++){       //先预先把第一组的数据填上，算出第一个滑动窗口的最大值，之后才能进入方法有比较
            queue.add(nums[i]);
        }
        res[num++] = queue.peek();

        for(int i = 0;i<nums.length-k;i++){
            queue.poll(nums[i]);    //把i的弹出 i+k的进入 相当于滑动窗口在移动
            queue.add(nums[i+k]);
            res[num++] = queue.peek();
        }

        return res;
    }
}

二、347前k个高频元素

 这道题主要是明确是用小顶堆还是大顶堆，小顶堆可以在二叉树尾部加入值，然后自动进行排序，首先是把k，v键值对存在map数组中，利用强制for循环，然后使用一个map的函数方法map.put(num,map.getOrDefault(num,0)+1);，这个函数方法可以将key键值对的出现次数直接放入map数组中。

然后使用优先队列构建小顶堆，因为这样每次从队尾插入，然后自动排序之后，每次堆顶存储的都k个中最小的值，所以每次让元素进来的时候和堆顶的元素（pq.peek()[1]：注意这里比较的是堆顶元素的第二位，也就是他的出现次数，即频次）比较即可，如果比他小就不用add进去，比他大就把堆顶的值poll掉，然后加入这个新值，堆里(优先队列)自动完成排序：
PriorityQueue<int[]> pq = new PriorityQueue<>((m1,m2) -> (m1[1] - m2[1]));

这个优先队列的意思就是(m1,m2) -> (m1[1] - m2[1])这样的形式
如果m1[1]大于m2[1]，则m1[1] - m2[1]的结果为正数，表示m1应该在排序后位于m2之前。
如果m1[1]小于m2[1]，则m1[1] - m2[1]的结果为负数，表示m2应该在排序后位于m1之前。
如果m1[1]等于m2[1]，则m1[1] - m2[1]的结果为0，表示m1和m2在排序后的相对位置不变（或者根据其他可能的比较逻辑，可能仍然有先后之分）。
在PriorityQueue中，这个比较器决定了队列的头部（通过poll()或peek()方法访问的元素）总是包含按照第二个元素排序后最小的数组。

补充：

PriorityQueue<Integer> 与 PriorityQueue<int[]> 是两种不同的数据结构：

1. PriorityQueue<Integer>:

   • 这是一个整数优先队列，存储的是单个整数值。
   • 使用这种结构，你可以按整数的自然顺序或使用提供的比较器来确定元素的优先级。

2. PriorityQueue<int[]>:

   • 这是一个整数数组优先队列，存储的是整数数组。
   • 使用这种结构，你可以按数组中的某个元素或一系列元素的值来确定元素的优先级。

如果你只是想按整数值的优先级来存储和检索元素，那么使用PriorityQueue<Integer> 是更合适的选择。

如果你想按整数数组中的某个元素（例如，数组中的第二个整数）的优先级来存储和检索元素，那么使用PriorityQueue<int[]> 是更合适的选择。

所以，你应该根据你的需求来选择适当的数据结构。如果你的目的是按整数值的优先级进行排序，那么使用PriorityQueue<Integer> 是更简单和直接的方法。

当然，入堆的元素个数如果小于k，那就无脑将新元素add进堆中，然后直到堆中元素等于k个的时候，再进行上面的比较。

最后创建一个结果数组res，用来保存堆里存放的前k个出现次数最多的元素，但是这里要注意因为堆中每次poll()[0]出来的元素是k个中频次最小的元素，所以在for循环中要从i=k-1的位置开始存储，确保返回的元素是频次从大到小的顺序，最后返回res

代码如下：

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>();
        for(int num:nums){
            map.put(num,map.getOrDefault(num,0)+1);
        }

        //创建优先队列，来存小顶堆
        PriorityQueue<int[]> pq = new PriorityQueue<>((m1,m2) -> (m1[1] - m2[1]));
        for(Map.Entry<Integer,Integer> maplist : map.entrySet())
        {
            if(pq.size() < k){
                pq.add(new int[]{maplist.getKey(), maplist.getValue()});
            }else{
                if(maplist.getValue() > pq.peek()[1]){
                    pq.poll();
                    pq.add(new int[]{maplist.getKey(), maplist.getValue()});
                }
            }
        }

        int[] res = new int[k];
        for(int i=k-1;i >= 0 ;i--){
            res[i] = pq.poll()[0];
        }
        return res;
    }
}

三、总结

通过求滑动窗口最大值，以及前K个高频元素介绍了两种队列：单调队列和优先级队列，这是特殊场景解决问题的利器，是一定要掌握的

滑动窗口是单调队列，从大到小排列，然后peek的值是最大的值

前K个高频元素是优先级队列，自动从小到大排序，就是小顶堆，这里有很多固定的方法是需要注意的