239. 滑动窗口最大值
题目链接:239. 滑动窗口最大值 - 力扣（LeetCode）
题目
给你一个整数数组 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]
思路
暴力方法，遍历一遍的过程中每次从窗口中再找到最大的数值，这样很明显是O(n × k)的算法。
有的同学可能会想用一个大顶堆（优先级队列）来存放这个窗口里的k个数字，这样就可以知道最大的最大值是多少了， 但是问题是这个窗口是移动的，而大顶堆每次只能弹出最大值，我们无法移除其他数值，这样就造成大顶堆维护的不是滑动窗口里面的数值了。所以不能用大顶堆。
此时我们需要一个队列，这个队列呢，放进去窗口里的元素，然后随着窗口的移动，队列也一进一出，每次移动之后，队列告诉我们里面的最大值是什么。
这个队列应该长这个样子(c++)：
class MyQueue {
public:
void pop(int value) {
}
void push(int value) {
}
int front() {
return que.front();
}
};
每次窗口移动的时候，调用que.pop(滑动窗口中移除元素的数值)，que.push(滑动窗口添加元素的数值)，然后que.front()就返回我们要的最大值。
然后再分析一下，队列里的元素一定是要排序的，而且要最大值放在出队口，要不然怎么知道最大值呢。
但如果把窗口里的元素都放进队列里，窗口移动的时候，队列需要弹出元素。
那么问题来了，已经排序之后的队列 怎么能把窗口要移除的元素（这个元素可不一定是最大值）弹出呢。
其实队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。
那么这个维护元素单调递减的队列就叫做单调队列，即单调递减或单调递增的队列。
不要以为实现的单调队列就是 对窗口里面的数进行排序，如果排序的话，那和优先级队列又有什么区别了呢。
设计单调队列的时候，pop，和push操作要保持如下规则：
- pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作
- push(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止
保持如上规则，每次窗口移动的时候，只要问que.front()就可以返回当前窗口的最大值。
为了更直观的感受到单调队列的工作过程，以题目示例为例，输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3，动画如下：
在刚开始加入到单调队列的时候，由于前三位中 3 是最大值，所以在 3 之前的数("1")就不需要加入到队列，这样就保证pop的时候是最大值了。
使用单调队列的时间复杂度是 O(n) (注意nums 中的每个元素最多也就被 push 和 pop 各一次，没有任何多余操作，所以整体的复杂度还是 O(n) )。
代码
1 //解法一
2 //自定义数组
3 class MyQueue {
4 Deque<Integer> deque = new LinkedList<>();
5 //弹出元素时，比较当前要弹出的数值是否等于队列出口的数值，如果相等则弹出
6 //同时判断队列当前是否为空
7 void poll(int val) {
8 if (!deque.isEmpty() && val == deque.peek()) {
9 deque.poll();
10 }
11 }
12 //添加元素时，如果要添加的元素大于入口处的元素，就将入口元素弹出
13 //保证队列元素单调递减
14 //比如此时队列元素3,1，2将要入队，比1大，所以1弹出，此时队列：3,2
15 void add(int val) {
16 while (!deque.isEmpty() && val > deque.getLast()) {
17 deque.removeLast();
18 }
19 deque.add(val);
20 }
21 //队列队顶元素始终为最大值
22 int peek() {
23 return deque.peek();
24 }
25 }
26
27 class Solution {
28 public int[] maxSlidingWindow(int[] nums, int k) {
29 if (nums.length == 1) {
30 return nums;
31 }
32 int len = nums.length - k + 1;
33 //存放结果元素的数组
34 int[] res = new int[len];
35 int num = 0;
36 //自定义队列
37 MyQueue myQueue = new MyQueue();
38 //先将前k的元素放入队列
39 for (int i = 0; i < k; i++) {
40 myQueue.add(nums[i]);
41 }
42 res[num++] = myQueue.peek();
43 for (int i = k; i < nums.length; i++) {
44 //滑动窗口移除最前面的元素，移除是判断该元素是否放入队列
45 myQueue.poll(nums[i - k]);
46 //滑动窗口加入最后面的元素
47 myQueue.add(nums[i]);
48 //记录对应的最大值
49 res[num++] = myQueue.peek();
50 }
51 return res;
52 }
53 }
54
55 //解法二
56 //利用双端队列手动实现单调队列
57 /**
58 * 用一个单调队列来存储对应的下标，每当窗口滑动的时候，直接取队列的头部指针对应的值放入结果集即可
59 * 单调队列类似 （tail -->） 3 --> 2 --> 1 --> 0 (--> head) (右边为头结点，元素存的是下标)
60 */
61 class Solution {
62 public int[] maxSlidingWindow(int[] nums, int k) {
63 ArrayDeque<Integer> deque = new ArrayDeque<>();
64 int n = nums.length;
65 int[] res = new int[n - k + 1];
66 int idx = 0;
67 for(int i = 0; i < n; i++) {
68 // 根据题意，i为nums下标，是要在[i - k + 1, i] 中选到最大值，只需要保证两点
69 // 1.队列头结点需要在[i - k + 1, i]范围内，不符合则要弹出
70 while(!deque.isEmpty() && deque.peek() < i - k + 1){
71 deque.poll();
72 }
73 // 2.既然是单调，就要保证每次放进去的数字要比末尾的都大，否则也弹出
74 while(!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
75 deque.pollLast();
76 }
77
78 deque.offer(i);
79
80 // 因为单调，当i增长到符合第一个k范围的时候，每滑动一步都将队列头节点放入结果就行了
81 if(i >= k - 1){
82 res[idx++] = nums[deque.peek()];
83 }
84 }
85 return res;
86 }
87 }
扩展
首先要明确的是，题解中单调队列里的pop和push接口，仅适用于本题。
单调队列不是一成不变的，而是不同场景不同写法，总之要保证队列里单调递减或递增的原则，所以叫做单调队列。 不要以为本题中的单调队列实现就是固定的写法。
347.前 K 个高频元素
题目链接:347. 前 K 个高频元素 - 力扣（LeetCode）
题目
给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。
示例 1:
输入: nums = [1,1,1,2,2,3], k = 2 输出: [1,2]
示例 2:
输入: nums = [1], k = 1 输出: [1]
思路
这道题目主要涉及到如下三块内容：
- 要统计元素出现频率
- 对频率排序
- 找出前K个高频元素
首先统计元素出现的频率，这一类的问题可以使用map来进行统计。
然后是对频率进行排序，这里我们可以使用一种 容器适配器就是优先级队列。
什么是优先级队列呢？
其实就是一个披着队列外衣的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列。
而且优先级队列内部元素是自动依照元素的权值排列。
那么它是如何有序排列的呢？
Java中PriorityQueue可通过传入的Comparator的匿名内部类进行 从小到大 或者 从大到小排序
什么是堆呢？
堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆，小于等于左右孩子就是小顶堆。
所以大家经常说的大顶堆（堆头是最大元素），小顶堆（堆头是最小元素），如果懒得自己实现的话，就直接用priority_queue（优先级队列）就可以了，底层实现都是一样的，从小到大排就是小顶堆，从大到小排就是大顶堆。
本题我们就要使用优先级队列来对部分频率进行排序。
为什么不用快排呢， 使用快排要将map转换为 数组 的结构，然后对整个数组进行排序， 而这种场景下，我们其实只需要维护k个有序的序列就可以了，所以使用优先级队列是最优的。
此时要思考一下，是使用小顶堆呢，还是大顶堆？
有的同学一想，题目要求前 K 个高频元素，那么果断用大顶堆啊。
那么问题来了，定义一个大小为k的大顶堆，在每次移动更新大顶堆的时候，每次弹出都把最大的元素弹出去了，那么怎么保留下来前K个高频元素呢。
而且使用大顶堆就要把所有元素都进行排序，那能不能只排序k个元素呢？
所以我们要用小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。
寻找前k个最大元素流程如图所示：（图中的频率只有三个，所以正好构成一个大小为3的小顶堆，如果频率更多一些，则用这个小顶堆进行扫描）
如果用大顶堆空间复杂度会高于小顶堆。
代码
1 /*Comparator接口说明:
2 * 返回负数，形参中第一个参数排在前面；返回正数，形参中第二个参数排在前面
3 * 对于队列：排在前面意味着往队头靠
4 * 对于堆（使用PriorityQueue实现）：从队头到队尾按从小到大排就是最小堆（小顶堆），
5 * 从队头到队尾按从大到小排就是最大堆（大顶堆）--->队头元素相当于堆的根节点
6 * */
7 class Solution {
8 //解法1：基于大顶堆实现,空间复杂度高于解法2
9 public int[] topKFrequent1(int[] nums, int k) {
10 Map<Integer,Integer> map = new HashMap<>();//key为数组元素值,val为对应出现次数
11 for(int num:nums){
12 map.put(num,map.getOrDefault(num,0)+1);
13 }
14 //在优先队列中存储二元组(num,cnt),cnt表示元素值num在数组中的出现次数
15 //出现次数按从队头到队尾的顺序是从大到小排,出现次数最多的在队头(相当于大顶堆)
16 PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2)->pair2[1]-pair1[1]);
17 for(Map.Entry<Integer,Integer> entry:map.entrySet()){//大顶堆需要对所有元素进行排序
18 pq.add(new int[]{entry.getKey(),entry.getValue()});
19 }
20 int[] ans = new int[k];
21 for(int i=0;i<k;i++){//依次从队头弹出k个,就是出现频率前k高的元素
22 ans[i] = pq.poll()[0];
23 }
24 return ans;
25 }
26 //解法2：基于小顶堆实现
27 public int[] topKFrequent2(int[] nums, int k) {
28 Map<Integer,Integer> map = new HashMap<>();//key为数组元素值,val为对应出现次数
29 for(int num:nums){
30 map.put(num,map.getOrDefault(num,0)+1);
31 }
32 //在优先队列中存储二元组(num,cnt),cnt表示元素值num在数组中的出现次数
33 //出现次数按从队头到队尾的顺序是从小到大排,出现次数最低的在队头(相当于小顶堆)
34 PriorityQueue<int[]> pq = new PriorityQueue<>((pair1,pair2)->pair1[1]-pair2[1]);
35 for(Map.Entry<Integer,Integer> entry:map.entrySet()){//小顶堆只需要维持k个元素有序
36 if(pq.size()<k){//小顶堆元素个数小于k个时直接加
37 pq.add(new int[]{entry.getKey(),entry.getValue()});
38 }else{
39 if(entry.getValue()>pq.peek()[1]){//当前元素出现次数大于小顶堆的根结点(这k个元素中出现次数最少的那个)
40 pq.poll();//弹出队头(小顶堆的根结点),即把堆里出现次数最少的那个删除,留下的就是出现次数多的了
41 pq.add(new int[]{entry.getKey(),entry.getValue()});
42 }
43 }
44 }
45 int[] ans = new int[k];
46 for(int i=k-1;i>=0;i--){//依次弹出小顶堆,先弹出的是堆的根,出现次数少,后面弹出的出现次数多
47 ans[i] = pq.poll()[0];
48 }
49 return ans;
50 }
51 }
扩展
1、优先级队列更多知识可以参考:(46条消息) Java基本数据结构——优先级队列（堆）_tomatooooooooooo的博客-CSDN博客
2、在上述代码中Comparator匿名内部类定义方式的是lambda表达式，lambda表达式作用：简化匿名内部类的代码写法。
简化格式
(匿名内部类被重写的形参列表) ->{
被重写方法的方法体代码。
}
更多细节可以参考(46条消息) 让你秒懂的Lambda表达式超级详细讲解_bfhonor的博客-CSDN博客_lambda 表达式
3、总结，栈和队列在内存上是连续的吗？这取决与底层实现(链表或者数组)。
标签：deque,窗口,nums,队列,元素,随想录,int,347,239 From： https://www.cnblogs.com/xpp3/p/17125303.html