今天我们来讲一下单调队列与栈。

这两种数据结构虽然没有在c++的stl中有直接的实现，但是在做题过程中，很容易有单调队列（栈）的使用，尤其是在一些比较难的题目中。

单调队列

1.1 单调队列介绍

单调队列 是 队列中元素之间的关系具有单调性，而且，队首和队尾都可以进行出队操作，只有队尾可以进行入队操作，本质是有双端队列deque实现的。

---

我们以 单调递减的队列 为例子：

先打个比方：假如你在饭堂打饭时，有个人人高马大，急匆匆跑过来，看排了这么一长串队，心中急躁，从队列最后的一个人开始，看见好欺负的就赶走，自己站着，直到干不过的就停下，这就是单调递减队列。也就是允许两端弹出，只允许一端插入的队列（允许两端插入，只允许一端弹出的也属于双端队列）。

我们以 7 6 8 12 9 10 3 例子建立一个单调递减队列：

---

同理，如果是 建立一个单调递增队列：

我们也可换一个比方：排队的时候，年龄小的孩子要优先，如果这个小孩子发现前面的人比他大，就把他赶出队列，直到前面的那个人比他年龄还小，他就不动了。

显然，最后单调队列的对头不是最大元素，就是最小的元素。显然，如果只是想找数列中的极值得话，完全没必要用一个队列让元素“进进出出”，大家脑子都晕了。

以本人的拙见看，单调队列一般用来在一个动态小区间中寻找极值。

接下来我们直接通过例题来感受一下。

---

1.2 单调队列的应用

1.2.1 滑动窗口最大值

1.2.1.1 题目描述

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]

---

1.2.1.2 结题思路

这题其实有三种做法，这里我们先不讲单调队列的做法，现讲优先级队列大的方法。
原因在于【单调队列方法】实际上是【优先级队列方法】的一种优化，直接讲单调队列难度较大，不好理解。

ps:这里我们直接跳过遍历每个小窗口的高复杂度（O(nk)）做法。

方法一（优先队列）

对于「最大值」，我们可以想到一种非常合适的数据结构，那就是优先队列（堆），其中的大根堆可以帮助我们实时维护一系列元素中的最大值。

在c++中 底层用堆实现的适配器 是priority_queue（优先级队列）。不了解的同学可以看下面这篇博客：
【C++】手把手教你写出自己的Stack和Queue类

我们以数组【1,9,-1,-3,5,3,6,7】（k=3）为例子来讲解，我先将步骤图放在下面：

• 初始时，我们将数组 \textit{nums}nums 的前 kk 个元素放入优先队列中【上图中的1步骤】。
• 每当我们向右移动窗口时，我们就可以把一个新的元素放入优先队列中【上图中的2,3,4,5,6步】，此时堆顶的元素就是堆中所有元素的最大值 。但是这个堆中的最大值可能不是我们想要的，比如【上图中第3步】，我们将9入队，此时9为最值，但显然9都不在区间内，显然不是当前区间最大值。在这种情况下，这个值在数组中的位置一定出现在滑动窗口左边界的左侧。（即9在-1的左边），因此，当我们后续继续向右移动窗口时，这个值只会里滑动窗口越来越远，我们可以将其永久地从优先队列中移除。
• 我们不断地移除堆顶的元素，直到其确实出现在滑动窗口中。此时，堆顶元素就是滑动窗口中的最大值。为了方便判断堆顶元素与滑动窗口的位置关系，我们在优先队列需要同时存储元素本身和其下标。

---

这里为什么要说“不断地移除堆顶的元素，直到其确实出现在滑动窗口中”，这是因为，有时候可能会出现几个队列内元素实际上都不在滑动窗口的情况：

比如说【1,9,9,-3,5,3,6,7】，在下图的第4步，我们删了两次队头元素才结束。

---

实现代码

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size();
        priority_queue<pair<int, int>> q;
        for (int i = 0; i < k; ++i) {
            q.emplace(nums[i], i);
        }
        vector<int> ans = {q.top().first};
        for (int i = k; i < n; ++i) {
            q.emplace(nums[i], i);
            while (q.top().second <= i - k) {
                q.pop();
            }
            ans.push_back(q.top().first);
        }
        return ans;
    }
};

复杂度分析：

• 时间复杂度：O(nlogn)，其中 nn 是数组 nums 的长度。在最坏情况下，数组 nums 中的元素单调递增，那么最终优先队列中包含了所有元素，没有元素被移除。由于将一个元素放入优先队列的时间复杂度为O(logn)，因此总时间复杂度为O(nlogn)。

• 空间复杂度：O(n)，即为优先队列需要使用的空间。这里所有的空间复杂度分析都不考虑返回的答案需要的 O(n) 空间，只计算额外的空间使用。

---

方法二 （单调队列）

我们可以顺着方法一的思路继续进行优化。

我们知道，优先级队列的关键是对一个窗口内的元素用大堆排降序，但是实际上，队列没有必要维护窗口中的所有元素。只需要维护有可能成为窗口中最大值的元素即可，同时保持其单调递减性。

这是什么意思？ 我们举个例子，在一个移动窗口内，有两个数字满足 nums[i]<nums[j] ,且i<j。那么当滑动窗口向右移动时，只要 i还在窗口中，那么 j一定也还在窗口中，这是 i在 j 的左侧所保证的。同时，由于 nums[i]<nums[j]，nums[i]也不不可能成为最大值了。那么之前把num[i]留在队列里就失去了价值。

我们用一个窗口 【2 3 5 1 4】将两种方式对比。

打个不恰当的比方，一个国家有几个皇储，但是其中有几个根本没有一点机会，所以干脆退出竞争。宫廷也不用浪费资源培养他们了。

---

了解了大致的优化思路之后，我们来看一下过程：

老样子，看图说话，我们以【2 3 5 1 4 8 9 0】(k=5)这个数组为例子：

【纠正】上图中最后的0应该入队，存在笔误，感谢@愛ななせ 指出

• 当滑动窗口向右移动时，我们需要把一个新的元素放入队列中。为了保持队列的性质，我们会不断地将新的元素与队尾的元素相比较，如果前者大于等于后者，那么队尾的元素就可以被永久地移除，我们将其弹出队列。我们需要不断地进行此项操作，直到队列为空或者新的元素小于队尾的元素。
• 由于队列中下标对应的元素是严格单调递减的，因此此时队首下标对应的元素就是滑动窗口中的最大值。但与方法一中相同的是，此时的最大值可能在滑动窗口左边界的左侧，并且随着窗口向右移动，它永远不可能出现在滑动窗口中了。因此我们还需要不断从队首弹出元素，直到队首元素在窗口中为止。（在图上没体现）

所以说，这个单调队列还要保证为了可以同时弹出队首和队尾的元素，所以要是用双端队列deque去实现。

---

代码实现

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size();
        deque<int> q;
        //使用第一个窗口去初始化单调队列
        for (int i = 0; i < k; ++i) {
            while (!q.empty() && nums[i] >= nums[q.back()]) {
                q.pop_back();
            }
            q.push_back(i);//队列存储的是下标
        }
        //ans存储每个窗口的最大值
        vector<int> ans = {nums[q.front()]};
        
        for (int i = k; i < n; ++i) {
            while (!q.empty() && nums[i] >= nums[q.back()]) {
                q.pop_back();
            }
            q.push_back(i);
            //检查最大元素是否在窗口区间里
            if (q.front() <= i - k) {
                q.pop_front();
            }
            ans.push_back(nums[q.front()]);
        }
        return ans;
    }
};

复杂度分析：

• 时间复杂度：O(n)，其中 n是数组 \nums 的长度。每一个下标恰好被放入队列一次，并且最多被弹出队列一次，因此时间复杂度为 O(n)O(n)。

• 空间复杂度：O(k)。与方法一不同的是，在方法二中我们使用的数据结构是双向的，因此「不断从队首弹出元素」保证了队列中最多不会有超过 k+1 个元素，因此队列使用的空间为 O(k)

---

1.3 单调队列的模拟实现

看了上面的题，其实我们也可以自己实现一个MyQueue 类，相当于一个容器适配器。

设计单调队列，push()和pop()要保持如下的规则：

1. push(value) :如果push的元素value大于队尾的数值，那就将队尾的元素弹出直到value小于或等于入口元素的数值，或者直到队列为空。
2. pop() : 如果窗口要移除的元素value等于单调队列的队头元素，那么队列弹出队头元素 ，否则不做任何操作。这个表述虽然和上文题目中有点不一样，但是意思是相同的。

下面贴出myQueue的代码：

#pragma once
namespace yyk {
	template<class T,class Compare=greater<T>>
	class myQueue {

	public:
	
		void push(T value) {
			Compare com;
			while (!que.empty() && com(value , que.back())) {
				que.pop_back();
			}
			que.push_back(value);
		}

		void pop(T value) {
			if (!que.empty() && value == que.front()) {
				que.pop_front();
			}
		}

		const T& front() {
			return que.front();
		}
		bool empty() {
			return que.empty();
		}

	private:
		deque<T> que;
	};
}

---

同时我们也可以用我们模拟实现的单调栈来实现【滑动窗口最大值】

#include<iostream>
#include<vector>
#include<queue>
using namespace std;
#include"MyQueue.h"

void Print(yyk::myQueue<int> que) {
	while (!que.empty()) {
		cout << que.front() << " ";
		que.pop(que.front());
	}
	cout << endl;
}
vector<int>maxSlidingWindow(vector<int>& nums, int k) {
	yyk::myQueue<int> que;
	vector<int>ans;

	for (int i = 0; i < k; i++) {
		que.push(nums[i]);
	}
	ans.push_back(que.front());
	Print(que);

	for (int i = k; i < nums.size(); ++i) {
		que.pop(nums[i - k]);
		que.push(nums[i]);
		ans.push_back(que.front());
		Print(que);
	}

	return ans;
}

int main() {
	vector<int>v = { 1,9,9,-3,5,3,6,7 };
	maxSlidingWindow(v, 3);
}

如果这时候题目要我们求最小值也很简单，我们只要在实例化myQueue的时候，加上第二个模板参数就行了。

yyk::myQueue<int，Less<int>> que;

---

1.4 其他例题

之后补充。