代码随想录训练营D13-栈与队列篇 p3 | 239. 滑动窗口最大值、 347.前 K 个高频元素、总结

为甚无day12,because day12 is weekend day.

（一） 239. 滑动窗口最大值

（一刷至少需要理解思路）

之前讲的都是栈的应用，这次该是队列的应用了。
本题算比较有难度的，需要自己去构造单调队列，建议先看视频来理解。

题目/文章/视频链接

1. 思路

1.1 直观思路

暴力解题，数组划到每个窗口时，把每个窗口内也都遍历一遍。时间复杂度：O（mxk），m是数组的长度，k是窗口的长度。

1.2 代码随想录思路

这是使用单调队列的经典题目。
自己维护一个单调队列。这个队列，放进去窗口里的元素，然后随着窗口的移动，队列也一进一出，每次移动之后，队列告诉我们里面的最大值是什么。
所以这个队列需要有以下3个方法

void pop(int value) {}
void push(int value) {}
int peek() {
   return que.peek();
}

但是没有这样的数据结构，需要我们自己实现。
一个问题：已经排序之后的队列 怎么能把窗口要移除的元素（这个元素可不一定是最大值）弹出呢。
答:其实队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。（即元素入队时，若前面元素都没有当前元素大，则将前面元素都弹出，让目前最大的数在队头）

单调队列是指：维护元素单调递减的队列。但并不是说对队列中的元素排序，排序的话就是优先级队列了。

举例说明：对于窗口里的元素{2, 3, 5, 1 ,4}，单调队列里只维护{5, 4} 就够了（前面比5小的都出队了），保持单调队列里单调递减，此时队列出口元素就是窗口里最大元素。

所以，若能维护这样一个队列，那front()方法很简单。关键是pop、push。
pop()//由于在入队时，会将当前最大值前面 比它小的都出队，所以如果窗口要移除的元素比当前最大值小（也就是比队头元素小），那么不用操作，因为该元素早就被pop了。若窗口要移除元素就是队头元素，那么队头pop
push()//当前元素比队尾元素大不? 比队尾大就移除队尾元素，直到当前元素比队尾元素小。要保持整体的从大到小排列的顺序，不符合顺序就移除。

2. 代码

class MyQueue{
   Deque<Integer> deque = new ArrayDeque<>();
   //提供三个方法

   //参数是窗口要移除元素。
   //如果窗口要移除的元素比当前最大值小（也就是比队头元素小），那么不用操作(因为该元素早就被pop了)
   // 若窗口要移除元素==队头元素，那么队头pop
   void poll(int value) {
       if(!deque.isEmpty() && value == peek() ){
           deque.poll();
       }
   }

   //当前元素比队尾元素大不?
   //比队尾大就移除队尾元素，直到当前元素比队尾元素小。整体队列要从大到小排列
   void add(int value) {
       while(!deque.isEmpty() && value > deque.getLast()){
           deque.removeLast();
       }
       deque.add(value);
   }
   int peek() {
       return deque.peek();
   }

}

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int[] result = new int[nums.length - k + 1];

        MyQueue myQueue = new MyQueue();
        for(int i = 0; i < k; ++i){
            myQueue.add(nums[i]);
        }
        int num = 0;//记录结果数组的长度
        result[num++] = myQueue.peek();
        for(int j = k; j < nums.length; ++j){//j：窗口右侧边边的下标
            myQueue.add(nums[j]);
            myQueue.poll(nums[j - k]);
            result[num++] = myQueue.peek();
        }
        return result;
    }
}

（二） 347.前 K 个高频元素

（一刷至少需要理解思路）

大/小顶堆的应用， 在C++中就是优先级队列
本题是 大数据中取前k值 的经典思路，了解想法之后，不算难。

题目/文章/视频链接

1. 思路

直观思路：
使用map，key存数值，value存储数值出现的次数。最终对map中的value按从大到小排序，取出前k个key并返回。
那么有必要对所有数据都进行排序吗？无。我们只需维护一个前k个元素的有序列即可。
此时，考虑用大顶堆、小顶堆这样的数据结构。

这里使用小顶堆，只需维护一个大小为k的小顶堆。因为小顶堆是最小的元素在根节点，并且父结点比孩子结点都大。而且小顶堆在更新元素时，是插入一个元素，同时弹出堆顶的元素。

2. 代码

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        //将数组元素读入map，key是元素数值，value是出现频率
        Map<Integer, Integer> map = new HashMap<>();
        for(int n : nums){
            map.put(n, map.getOrDefault(n, 0) + 1);
        }

        //使用优先队列(小顶堆) 维护大小为k的序列
        //在优先队列中存储二元组（num，cnt）num：元素值；cnt：出现次数
        //按出现次数进行优先级排序
        PriorityQueue<int[]> pq = new PriorityQueue<>((arr1, arr2) -> (arr1[1] - arr2[1]));
        //遍历map中的键值对
        for(Map.Entry<Integer, Integer> entry : map.entrySet()){
            //小顶堆元素个数<k时，直接添加
            if(pq.size() < k){
                pq.add(new int[]{entry.getKey(), entry.getValue()});
            }else {
                //如果待添加元素比小顶堆 堆顶 的元素出现频率还小，那就不用添加了；
                //待添加元素频率 > 堆顶元素出现频率，堆顶元素弹出，再将当前元素key-value加入堆中
                if(entry.getValue() > pq.peek()[1]){
                    pq.poll();
                    pq.add(new int[]{entry.getKey(), entry.getValue()});
                }
            }
        }

        //将堆顶元素遍历到数组中,题中说可以按任意顺序返回
        int[] result = new int[k];
        while(!pq.isEmpty()){
            result[--k] = pq.poll()[0];
        }
        return result;
    }
}

3. 实现过程中的问题

3.1 优先队列

java中的PriorityQueue默认情况下是小顶堆。
大顶堆写法：
1）匿名内部类

A=new PriorityQueue<>(new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
		// TODO 自动生成的方法存根
		return o2-o1;
	}
});

2）lambda表达式

B=new PriorityQueue<>((x,y) -> (y-x));

(三)总结

栈与队列做一个总结吧，加油
https://programmercarl.com/%E6%A0%88%E4%B8%8E%E9%98%9F%E5%88%97%E6%80%BB%E7%BB%93.html

1.栈的经典应用：消消乐
在匹配左右括号时的小技巧，可以在输入左括号时，直接存入右括号。这样到时候与栈顶元素相消时，可以直接用==消掉，而不必再想如何给’(‘与’)'配对。

2.队列：单调队列 与优先队列
2.1 单调队列。是自己实现的一种数据结构，维护的是当前队头是最大的元素，整个队列是从大到小的。但这种顺序不是由排序得到的，而是在入队的时候，把不符合这种顺序的数字提前从队尾处弹出了。
2.2优先队列。底层实现是大顶堆、小顶堆。一般要前k个，后k个之类的题目要想到。优先队列是通过排序实现的。