题目：
给你一个整数数组 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]
提示：
1 <= nums.length <= 105
-104 <= nums[i] <= 104
1 <= k <= nums.length
思路：
这是使用单调队列的经典题目。
难点是如何求一个区间里的最大值呢？ （这好像是废话），暴力一下不就得了。
暴力方法，遍历一遍的过程中每次从窗口中再找到最大的数值，这样很明显是O(n × k)的算法。
有的同学可能会想用一个大顶堆（优先级队列）来存放这个窗口里的k个数字，这样就可以知道最大的最大值是多少了， 但是问题是这个窗口是移动的，而大顶堆每次只能弹出最大值，我们无法移除其他数值，这样就造成大顶堆维护的不是滑动窗口里面的数值了。所以不能用大顶堆。
此时我们需要一个队列，这个队列呢，放进去窗口里的元素，然后随着窗口的移动，队列也一进一出，每次移动之后，队列告诉我们里面的最大值是什么。
这个队列应该长这个样子：
class MyQueue {
public:
void pop(int value) {
}
void push(int value) {
}
int front() {
return que.front();
}
};
每次窗口移动的时候，调用que.pop(滑动窗口中移除元素的数值)，que.push(滑动窗口添加元素的数值)，然后que.front()就返回我们要的最大值。
这么个队列香不香，要是有现成的这种数据结构是不是更香了！
其实在C++中，可以使用 multiset 来模拟这个过程，文末提供这个解法仅针对C++，以下讲解我们还是靠自己来实现这个单调队列。
然后再分析一下，队列里的元素一定是要排序的，而且要最大值放在出队口，要不然怎么知道最大值呢。
但如果把窗口里的元素都放进队列里，窗口移动的时候，队列需要弹出元素。
那么问题来了，已经排序之后的队列 怎么能把窗口要移除的元素（这个元素可不一定是最大值）弹出呢。
大家此时应该陷入深思…
其实队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。
那么这个维护元素单调递减的队列就叫做单调队列，即单调递减或单调递增的队列。C++中没有直接支持单调队列，需要我们自己来实现一个单调队列
不要以为实现的单调队列就是 对窗口里面的数进行排序，如果排序的话，那和优先级队列又有什么区别了呢。
来看一下单调队列如何维护队列里的元素。
动画如下：
对于窗口里的元素{2, 3, 5, 1 ,4}，单调队列里只维护{5, 4} 就够了，保持单调队列里单调递减，此时队列出口元素就是窗口里最大元素。
此时大家应该怀疑单调队列里维护着{5, 4} 怎么配合窗口进行滑动呢？
设计单调队列的时候，pop，和push操作要保持如下规则：
- pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作
- push(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止
保持如上规则，每次窗口移动的时候，只要问que.front()就可以返回当前窗口的最大值。
为了更直观的感受到单调队列的工作过程，以题目示例为例，输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3，动画如下：
那么我们用什么数据结构来实现这个单调队列呢？
使用deque最为合适，常用的queue在没有指定容器的情况下，deque就是默认底层容器。
基于刚刚说过的单调队列pop和push的规则，代码不难实现，如下：
class MyQueue{ // 单调队列（从大到小）
public:
deque<int> que; // 使用deque来实现单调队列，也就是该题的滑动窗口
// 滑动窗口时弹出窗口第一个元素时用的
// 每次弹出的时候，如果que非空且当前要弹出的数值等于队列出口元素的数值，则弹出
void pop(int value){
if(!que.empty() && value == que.front()){
que.pop_front();
}
}
// 滑动窗口时填充窗口最后一个元素时用的
// 如果push的数值大于入口元素的数值，则将入口元素弹出，直到push的数值小于等于队列入口元素的数值为止
// 这样就保证了队列里的素质是单调从大到小的
void push(int value){
while(!que.empty() && value > que.back()){
que.pop_back();
}
que.push_back(value);
}
// 队列前端的值front就是窗口中的最大值
int front(){
return que.front();
}
};
这样我们就用deque实现了一个单调队列，接下来解决滑动窗口最大值的问题就很简单了，直接看代码吧。
代码：
- 写法1：基于上述分析实现单调队列
class Solution {
private:
class MyQueue{ // 单调队列（从大到小）
public:
deque<int> que; // 使用deque来实现单调队列，也就是该题的滑动窗口
// 滑动窗口时弹出窗口第一个元素时用的
// 每次弹出的时候，如果que非空且当前要弹出的数值等于队列出口元素的数值，则弹出
void pop(int value){
if(!que.empty() && value == que.front()){
que.pop_front();
}
}
// 滑动窗口时填充窗口最后一个元素时用的
// 如果push的数值大于入口元素的数值，则将入口元素弹出，直到push的数值小于等于队列入口元素的数值为止
// 这样就保证了队列里的素质是单调从大到小的
void push(int value){
while(!que.empty() && value > que.back()){
que.pop_back();
}
que.push_back(value);
}
// 队列前端的值front就是窗口中的最大值
int front(){
return que.front();
}
};
public:
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
MyQueue que;
vector<int> result;
// 先将前k个元素放进队列，即滑动窗口
for(int i = 0; i < k; i++){
que.push(nums[i]);
}
// result记录当前窗口的最大值
result.push_back(que.front());
for(int i = k; i < nums.size(); i++){
que.pop(nums[i - k]); // 移除窗口最前面的元素
que.push(nums[i]); // 填充窗口末端元素进行滑动
result.push_back(que.front()); // 记录当前窗口的最大值
}
return result;
}
};
- 写法2：基于C++自带容器multiset实现
class Solution {
public:
vector<int> maxSlidingWindow(vector<int>& nums, int k) {
multiset<int> set1; //multiset作为滑动窗口，且其会对元素从小到大排序
vector<int> result;
// 在遍历原数组的时候，只需要把窗口的头元素加入到multiset中，然后把窗口的尾元素删除即可。因为multiset是有序的，并且提供了*rbegin()，可以直接获取窗口最大值。
for(int i = 0; i < nums.size(); i++){
if(i >= k) set1.erase(set1.find(nums[i - k]));
set1.insert(nums[i]);
if(i >= k - 1) result.push_back(*set1.rbegin());
}
return result;
}
};
总结：
时间复杂度: O(n)
空间复杂度: O(k)
nums 中的每个元素最多也就被 push_back 和 pop_back 各一次，没有任何多余操作，所以整体的时间复杂度还是 O(n)。
C++中deque是stack和queue默认的底层实现容器，deque是可以两边扩展的，而且deque里元素并不是严格的连续分布的。