在处理数组类算法问题时,我们经常需要快速找到某个元素左侧或右侧满足特定条件的第一个元素,或者维护一个滑动窗口内的极值。暴力遍历虽然直观,但在数据量较大时往往超时。单调栈和单调队列正是为此类问题量身定制的高效数据结构,它们能将时间复杂度从 O(n²) 优化到 O(n)。本文将结合实际例题,系统梳理这两种结构的核心思想与实现细节,并穿插与 Java、Go、Python 等语言的对比思考,帮助你真正吃透这一知识点。

一、什么是单调栈?核心思想与适用场景

单调栈,本质上是一个栈内元素保持单调性(单调递增或单调递减)的栈结构。它的威力在于:当新元素准备入栈时,通过弹出破坏单调性的栈顶元素,可以快速确定某些元素的“下一个更大/更小值”。

关键理解:栈中保留的,是那些尚未找到答案的元素。一旦某个元素遇到了比它大的新元素,它就被弹出,同时记录答案。这种“后进先出”的弹栈顺序,恰好保证了每个元素只进出栈一次,整体复杂度为 O(n)。

单调栈的典型应用场景包括:

  • 寻找每个元素右边第一个比它大的元素(下一个更大元素)
  • 寻找每个元素左边第一个比它小的元素
  • 计算柱状图中最大的矩形面积
  • 股票价格跨度问题

值得注意的是,无论你用 C++ 的 std::stack,还是 Java 的 ArrayDeque、Python 的 list 模拟栈,核心逻辑完全一致。Go 语言中通常用切片配合 append 和切片截断来实现,TypeScript 和 JavaScript 则可以直接用数组的 push/pop。掌握思想比记住 API 更重要。✅

二、单调栈实战:求解下一个更大元素

我们以洛谷 P5788 为例:给定长度为 n 的整数数列,定义 f(i) 为第 i 个元素之后第一个大于 a[i] 的元素的下标,若不存在则为 0,要求输出所有 f(i)。

由于数据范围较大,逐个向后扫描的 O(n²) 做法必然超时。此时应选用单调非递增栈(从栈底到栈顶元素不递增)。为什么不是递增栈?因为递增栈无法有效维护“等待更大元素”的候选集合。

具体流程如下:

  1. 遍历每个元素,将其下标入栈前,先检查栈顶对应的元素值
  2. 若栈顶元素小于当前元素,说明当前元素就是栈顶元素的“下一个更大值”,弹出并记录答案
  3. 重复上述弹出过程,直到栈为空或栈顶元素不小于当前元素
  4. 将当前元素下标压入栈中

下面是该思路的参考实现:

#include
#define ll long long
using namespace std;
ll n,f[4000050];
struct node{
	ll val,pos;
}a[4000050];
stacksk;
void solve(node x){
	while(!sk.empty()){
		node y=sk.top();
		if(y.val>n;
	for(int i=1;i<=n;i++){
		cin>>a[i].val;
		a[i].pos=i;
		solve(a[i]);
	}
	for(int i=1;i<=n;i++){
		cout<

⚠️ 实践提醒:栈中存储的是下标而非数值,这样才能方便地回填答案数组。另外,遍历结束后栈中剩余的元素对应的 f(i) 保持初始值 0 即可。这种“存下标”的技巧在 Java、Go、Python 实现中同样适用,是通用范式。

[AFFILIATE_SLOT_1]

三、什么是单调队列?滑动窗口的利器

单调队列与单调栈思想相通,但它是一个两端都可以操作的队列,通常用双端队列 deque 实现。它最经典的应用就是滑动窗口最值问题。

以洛谷 P1886 为例:给定长度为 n 的序列和大小为 k 的窗口,窗口从左向右每次滑动一个单位,求每次滑动后窗口内的最小值与最大值。

为什么用单调队列?假设我们维护最小值,考虑窗口中两个元素 i 和 j(j > i 且 a[j] < a[i])。由于 j 出现得更晚、消失得也更晚,且值更小,那么 i 就永远不可能成为未来窗口的最小值——i 可以被安全地淘汰。这正是单调队列“从队尾弹出”的依据。

因此,求最小值时应维护一个单调不递减队列(队首最小)。操作要点:

  • 入队时:从队尾不断弹出比当前元素大的元素,保证单调性
  • 出队时:检查队首元素的下标是否已经滑出窗口范围,若滑出则从队首移除
  • 每次窗口滑动后,队首元素即为当前窗口的最值

求最大值时逻辑对称,只需维护单调不递增队列即可。这种“存下标 + 双端淘汰”的模式,在 JavaScript、TypeScript 中用数组配合头指针也能高效实现,Python 则常用 collections.deque。

四、单调队列实战:滑动窗口最值实现

下面给出滑动窗口最小值的核心代码。整体思路是先用一个循环构建初始窗口的单调队列,然后窗口每右移一格,就执行“尾部淘汰 + 头部过期检查 + 记录答案”三步操作。

#include
#define ll long long
using namespace std;
ll n,bigg[1000050],smalll[1000050],k;
struct node{
	ll val,pos;
}a[1000050];
dequeq1,q2;
void big_solve(node x){
	while(!q1.empty()){
		node n1=q1.front();
		if(n1.pos<=x.pos-k)q1.pop_front();
		else break;
	}
	while(!q1.empty()){
		node n1=q1.back();
		if(n1.val<=x.val)q1.pop_back();
		else break;
	}
	q1.push_back(x);
	bigg[x.pos]=q1.front().val;
}
void small_solve(node x){
	while(!q2.empty()){
		node n1=q2.front();
		if(n1.pos<=x.pos-k)q2.pop_front();
		else break;
	}
	while(!q2.empty()){
		node n1=q2.back();
		if(n1.val>=x.val)q2.pop_back();
		else break;
	}
	q2.push_back(x);
	smalll[x.pos]=q2.front().val;
}
signed main(){
	cin>>n>>k;
	for(int i=1;i<=n;i++){
		cin>>a[i].val;
		a[i].pos=i;
		big_solve(a[i]);
		small_solve(a[i]);
	}
	for(int i=k;i<=n;i++){
		cout<

✅ 复杂度分析:每个元素最多入队一次、出队一次,因此总时间复杂度为 O(n),空间复杂度为 O(k)。相比暴力枚举每个窗口的 O(nk),性能提升非常明显。

⚠️ 常见坑点:判断队首是否过期时,要用下标之差与窗口大小比较,而不是简单地比较元素个数;同时要注意队列中存储的是下标,取值时需再访问原数组。这些细节在 Go 的切片实现和 Java 的 deque 实现中同样容易出错,务必仔细。

五、两种结构的对比与延伸思考

虽然单调栈和单调队列名字相似,但它们的适用场景有明显区别:

  • 单调栈:单端操作,适合解决“下一个更大/更小元素”这类方向性查找问题
  • 单调队列:双端操作,适合维护区间(窗口)内的极值,并支持过期淘汰

从语言实现角度看,C++ 的 deque 是最贴合的数据结构;Java 推荐 ArrayDeque(比 LinkedList 性能更好);Go 可以用切片模拟双端队列;Python 用 deque 即可;JavaScript/TypeScript 则常用数组加头指针或直接 shift(注意 shift 在大数据量下性能较差,建议用指针)。

延伸练习建议:掌握模板后,可以尝试“接雨水”“柱状图中最大矩形”“队列的最大值”等经典题目,进一步体会单调性维护的精髓。很多动态规划优化问题(如决策单调性优化)也以单调队列为基础,值得深入。

[AFFILIATE_SLOT_2]

总结

单调栈与单调队列的核心都在于用单调性淘汰无用元素,从而把 O(n²) 的暴力优化到 O(n)。单调栈解决“下一个更大/更小”类查找问题,单调队列解决滑动窗口极值问题。掌握“存下标、尾部淘汰、头部过期”这套通用范式,再结合具体语言的数据结构特性灵活实现,就能在各类算法题中游刃有余。建议多动手复现模板,并尝试迁移到 Java、Go、Python 等语言中加深理解。✅