acwing算法基础之数据结构--栈、单调栈、队列和单调队列

已于 2023-12-09 17:18:16 修改
阅读量354 收藏
点赞数
分类专栏： Acwing 文章标签： 数据结构 算法
于 2023-10-14 22:57:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YMWM_/article/details/133830228
版权

目录

1 知识点

栈：先进后出。先进的就是栈底，后进的就是栈顶。后进先出嘛，所以在栈顶弹出元素。

队列：先进先出。先进的就是队头，后进的就是队尾。先进先出嘛，所以在队头弹出元素。

单调栈：输入数组，求每个元素左边的某个元素，满足（1）比它小，（2）离它最近。

//输入数组nums
//输出上述要求的数值
for (int i = 0; i < nums.size(); ++i) {
	while (tt && stk[tt] >= nums[i]) {
		tt--;
	}
	if (tt) {
		cout << stk[tt] << " ";
	} else {
		cout << "-1 ";
	}
	stk[++tt] = nums[i];
}
cout << endl;

单调队列：求滑动窗口中的最大值或最小值，

//输入数组nums，区间长度k
//（1）找到滑动窗口的最小值
int hh = 0, tt = -1;
for (int i = 0; i < nums.size(); ++i) {
	if (hh <= tt && q[hh] < i - k + 1) {
		hh++;
	}
	while (hh <= tt && nums[q[tt]] >= nums[i]) {
		tt--;
	}
	q[++tt] = i;
	//最小值nums[q[hh]]
	if (i >= k-1) {
		cout << nums[q[hh]] << " ";
	}
}
cout << endl;

//滑动区间的最大值
int hh = 0, tt = -1;
for (int i = 0; i < nums.size(); ++i) {
	if (hh <= tt && q[hh] < i - k + 1) {
		hh++;
	}
	while (hh <= tt && nums[q[tt]] <= nums[i]) {
		tt--;
	}
	q[++tt] = i;
	//最大值nums[q[hh]]
	if (i >= k - 1) {
		cout << nums[q[hh]] << " ";
	}
}
cout << endl;

用数组来模拟上述数据结构。

2 模板

（一）用数组来模拟栈的模板，

const int N = 1e6 + 10;
int stk[N], tt = 0;//tt表示栈顶下标，stk[tt]表示栈顶的值。

//（1）往栈中插入数值x
stk[++tt] = x;

//（2）删除栈顶元素
tt--;

//（3）栈顶元素的值
stk[tt];

//（4）判断栈是否为空
if (tt > 0) {
	//栈不为空
} else {
	//栈为空
}

（二）用数组来模拟队列的模板，

const int N = 1e6 + 10;
int q[N], hh = 0, tt = -1;//hh表示队头下标，tt表示队尾下标。q[hh]表示队头的值，q[tt]表示队尾的值。

//（1）往队列中插入数值x
q[++tt] = x;

//（2）往队列中删除元素
hh++;

//（3）取队头元素
q[hh];

//（4）取队尾元素
q[tt];

//（5）判断队列是否为空
if (hh <= tt) {
	//队列不为空
} else {
	//队列为空
}

3 单调栈题目

题目1：给定 n n n和 x 0 , x 1 , x 2 , ⋯   , x n − 1 x_0,x_1,x_2,\cdots,x_{n-1} x0​,x1​,x2​,⋯,xn−1​，求每个 x i x_i xi​左边最近的且小于它的数，如果这个数不存在，则输出-1。

解题思路：单调栈。

C++代码如下，

#include <iostream>
#include <vector>

using namespace std;

const int N = 1e5 + 10;
int n;

int main() {
    cin >> n;
    
    //找到arr[i]左边最近的且小于它的元素
    vector<int> stk;
    for (int i = 0; i < n; ++i) {
        int x;
        cin >> x;
        
        while (!stk.empty() && stk.back() >= x) {
            stk.pop_back();
        }
        
        if (stk.empty()) {
            cout << "-1 "; 
        } else {
            cout << stk.back() << " ";
        }
        
        stk.emplace_back(x);
    }
    return 0;
}

测试用例，

输入：
5
3 4 2 7 5
输出：
-1 3 -1 2 2

题目2：给定 n n n和 x 0 , x 1 , x 2 , ⋯   , x n − 1 x_0,x_1,x_2,\cdots,x_{n-1} x0​,x1​,x2​,⋯,xn−1​，求每个 x i x_i xi​左边最近的且小于等于它的数，如果这个数不存在，则输出-1。

同样使用单调栈来求解。

C++代码如下，

#include <iostream>
#include <vector>

using namespace std;

const int N = 1e5 + 10;
int n;

int main() {
    cin >> n;
    
    //找到arr[i]左边最近的且小于等于它的元素
    vector<int> stk;
    for (int i = 0; i < n; ++i) {
        int x;
        cin >> x;
        
        while (!stk.empty() && stk.back() > x) {
            stk.pop_back();
        }
        
        if (stk.empty()) {
            cout << "-1 "; 
        } else {
            cout << stk.back() << " ";
        }
        
        stk.emplace_back(x);
    }
    return 0;
}

测试用例，

输入：
6
3 4 2 5 7 5
输出：
-1 3 -1 2 5 5

题目3：给定 n n n和 x 0 , x 1 , x 2 , ⋯   , x n − 1 x_0,x_1,x_2,\cdots,x_{n-1} x0​,x1​,x2​,⋯,xn−1​，求每个 x i x_i xi​右边最近的且小于它的数，如果这个数不存在，则输出-1。

同样使用单调栈来求解，只不过遍历顺序需要从 n − 1 n-1 n−1到 0 0 0。

C++代码如下，

#include <iostream>
#include <vector>

using namespace std;

const int N = 1e5 + 10;
int x[N];
int n;

int main() {
    cin >> n;
    
    for (int i = 0; i < n; ++i) {
        cin >> x[i];
    }
    
    //找到arr[i]右边最近的且小于它的元素
    vector<int> right(n);
    vector<int> stk;    
    for (int i = n - 1; i >= 0; --i) {
        while (!stk.empty() && stk.back() >= x[i]) {
            stk.pop_back();
        }
        if (stk.empty()) {
            right[i] = -1;
        } else {
            right[i] = stk.back();
        }
        stk.emplace_back(x[i]);
    }
    
    for (int i = 0; i < n; ++i) cout << right[i] << " ";
    cout << endl;
    
    return 0;
}

测试用例，

输入：
6
3 4 2 5 7 5
输出：
2 2 -1 -1 5 -1

题目4：给定 n n n和 x 0 , x 1 , x 2 , ⋯   , x n − 1 x_0,x_1,x_2,\cdots,x_{n-1} x0​,x1​,x2​,⋯,xn−1​，求每个 x i x_i xi​右边最近的且小于等于它的数，如果这个数不存在，则输出-1。

同样使用单调栈来求解。

C++代码如下，

#include <iostream>
#include <vector>

using namespace std;

const int N = 1e5 + 10;
int x[N];
int n;

int main() {
    cin >> n;
    
    for (int i = 0; i < n; ++i) {
        cin >> x[i];
    }
    
    //找到arr[i]右边最近的且小于等于它的元素
    vector<int> right(n);
    vector<int> stk;    
    for (int i = n - 1; i >= 0; --i) {
        while (!stk.empty() && stk.back() > x[i]) {
            stk.pop_back();
        }
        if (stk.empty()) {
            right[i] = -1;
        } else {
            right[i] = stk.back();
        }
        stk.emplace_back(x[i]);
    }
    
    for (int i = 0; i < n; ++i) cout << right[i] << " ";
    cout << endl;
    
    return 0;
}

测试用例，

输入：
6
3 4 2 5 7 5
输出：
2 2 -1 5 5 -1

题目5：给定 n n n和 x 0 , x 1 , x 2 , ⋯   , x n − 1 x_0,x_1,x_2,\cdots,x_{n-1} x0​,x1​,x2​,⋯,xn−1​，求每个 x i x_i xi​左边最近的且大于它的数，如果这个数不存在，则输出-1。

同样使用单调栈来求解。

#include <iostream>
#include <vector>

using namespace std;

const int N = 1e5 + 10;
int n;
int a[N];
int res[N];

int main() {
    cin >> n;
    for (int i = 1; i <= n; ++i) cin >> a[i];
    
    //找到左边最近的且大于它的数，没有找到则输出-1。
    vector<int> stk;
    for (int i = 1; i <= n; ++i) {
        while (!stk.empty() && stk.back() <= a[i]) {
            stk.pop_back();
        }
        res[i] = stk.empty() ? -1 : stk.back();
        stk.emplace_back(a[i]);
    }
    
    //输出答案
    for (int i = 1; i <= n; ++i) {
        cout << res[i] << " ";
    }
    cout << endl;
    
    return 0;
}

测试用例，

输入：
6
3 4 2 2 7 5
输出：
-1 -1 4 4 -1 7

题目6：给定 n n n和 x 0 , x 1 , x 2 , ⋯   , x n − 1 x_0,x_1,x_2,\cdots,x_{n-1} x0​,x1​,x2​,⋯,xn−1​，求每个 x i x_i xi​左边最近的且大于等于它的数，如果这个数不存在，则输出-1。

C++代码如下，

#include <iostream>
#include <vector>

using namespace std;

const int N = 1e5 + 10;
int n;
int a[N];
int res[N];

int main() {
    cin >> n;
    for (int i = 1; i <= n; ++i) cin >> a[i];
    
    //找到左边最近的且大于等于它的数，没有找到则输出-1。
    vector<int> stk;
    for (int i = 1; i <= n; ++i) {
        while (!stk.empty() && stk.back() < a[i]) {
            stk.pop_back();
        }
        res[i] = stk.empty() ? -1 : stk.back();
        stk.emplace_back(a[i]);
    }
    
    //输出答案
    for (int i = 1; i <= n; ++i) {
        cout << res[i] << " ";
    }
    cout << endl;
    
    return 0;
}

测试用例，

输入：
6
3 4 2 2 7 5
输出：
-1 -1 4 2 -1 7

题目7：给定 n n n和 x 0 , x 1 , x 2 , ⋯   , x n − 1 x_0,x_1,x_2,\cdots,x_{n-1} x0​,x1​,x2​,⋯,xn−1​，求每个 x i x_i xi​右边最近的且大于它的数，如果这个数不存在，则输出-1。

C++代码如下，

#include <iostream>
#include <vector>

using namespace std;

const int N = 1e5 + 10;
int n;
int a[N];
int res[N];

int main() {
    cin >> n;
    for (int i = 1; i <= n; ++i) cin >> a[i];
    
    //找到右边最近的且大于它的数，没有找到则输出-1。
    vector<int> stk;
    for (int i = n; i >= 0; --i) {
        while (!stk.empty() && stk.back() <= a[i]) {
            stk.pop_back();
        }
        res[i] = stk.empty() ? -1 : stk.back();
        stk.emplace_back(a[i]);
    }
    
    //输出答案
    for (int i = 1; i <= n; ++i) {
        cout << res[i] << " ";
    }
    cout << endl;
    
    return 0;
}

测试用例，

输入：
6
3 4 2 2 7 5
输出：
4 7 7 7 -1 -1

题目8：给定 n n n和 x 0 , x 1 , x 2 , ⋯   , x n − 1 x_0,x_1,x_2,\cdots,x_{n-1} x0​,x1​,x2​,⋯,xn−1​，求每个 x i x_i xi​右边最近的且大于等于它的数，如果这个数不存在，则输出-1。

C++代码如下，

#include <iostream>
#include <vector>

using namespace std;

const int N = 1e5 + 10;
int n;
int a[N];
int res[N];

int main() {
    cin >> n;
    for (int i = 1; i <= n; ++i) cin >> a[i];
    
    //找到右边最近的且大于它的数，没有找到则输出-1。
    vector<int> stk;
    for (int i = n; i >= 0; --i) {
        while (!stk.empty() && stk.back() < a[i]) {
            stk.pop_back();
        }
        res[i] = stk.empty() ? -1 : stk.back();
        stk.emplace_back(a[i]);
    }
    
    //输出答案
    for (int i = 1; i <= n; ++i) {
        cout << res[i] << " ";
    }
    cout << endl;
    
    return 0;
}

测试用例，

输入：
6
3 4 2 2 7 5
输出：
4 7 2 7 -1 -1

4 单调队列题目

题目1：求滑动窗口内的最大值和最小值。

C++代码如下，

#include <iostream>
#include <vector>
#include <deque>

using namespace std;

const int N = 1e6 + 10;
int q[N], hh = 0, tt = -1;

int main() {
    int n, k;
    cin >> n >> k;
    vector<int> nums(n, 0);
    for (int i = 0; i < n; ++i) {
        cin >> nums[i];
    }
    
    deque<int> q;
    for (int i = 0; i < n; ++i) {
        if (!q.empty() && q.front() < i - k + 1) {//如果队头元素不在滑动区间内部，则弹出
            q.pop_front();
        } 
        while (!q.empty() && nums[q.back()] >= nums[i]) {//需要的是滑动区间内的最小值，因此，如果队尾元素大于等于当前元素，则弹出队尾元素
            q.pop_back();
        }
        q.push_back(i);//往队尾插入
        if (i >= k - 1) {
            cout << nums[q.front()] << " ";//输出队头元素
        }
    }
    cout << endl;
    
    q.clear();
    for (int i = 0; i < n; ++i) {
        if (!q.empty() && q.front() < i - k + 1) {
            q.pop_front();
        } 
        while (!q.empty() && nums[q.back()] <= nums[i]) {
            q.pop_back();
        }
        q.push_back(i);
        if (i >= k - 1) {
            cout << nums[q.front()] << " ";
        }
    }
    cout << endl;    
    
    return 0;
}
YMWM_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构--栈与队列.cpp
03-08
数据结构--栈与队列.cpp
AcWing第二章算法模板总结——数据结构
weixin_43389219的博客
06-03 386
一、链表与邻接表 二、栈与队列 三、KMP 四、Trie树 五、并查集 六、堆 七、哈希 八、C++ STL简介
AcWing—数据结构
astruggle___的博客
11-28 343
AcWing 算法基础可数据结构部分复习
AcWing算法学习笔记：数据结构（单链表 + 双链表 + 栈 + 队列 +单调栈 + 单调队列 + KMP + Trie + 并查集 + 堆 + 哈希表）
最新发布
一只可爱的小猴子的博客
02-04 476
并且取模的这个数需要是质数，并且尽可能离二的整次幂尽可能的远，这样发生冲突的概率是最小的。优化方法：将所有元素先乱序存入数组（建立起一个乱序完全二叉树），然后对这棵树的。初始建堆，若采用插入的方法，则时间复杂度为0(nlogn)这两种方法的删除操作都是开一个数组标记，不会真正进行删除。该优化方法由下图的证明可以得出时间复杂度为0(n)插入删除节点0（1）
acwing模板整理（第二讲）（数据结构）
foremost1的博客
08-27 440
acwing模板整理（第三讲）（数据结构）
【AcWing 学习】数据结构 + STL
萌宅鹿的技术小屋
08-10 844
链表与邻接表 单链表（静态链表） 双链表（静态链表） 栈与队列 模拟栈 模拟队列 表达式求值 单调栈 单调队列 kmp Trie 树 Trie 字符串统计 最大异或对 并查集 合并集合 连通块中点的数量 堆 堆排序 模拟堆 TODO 哈希表 模拟散列表 字符串哈希 STL vector pair string queue priority_queue stack deque set map bitset......
DataAndAlgorithm_C#数据结构与算法_栈和队列_
09-29
包含线性表，栈，队列，串等结构的代码示例，及一些栈和队列的应用。
数据结构与算法-实验3 栈和队列
11-19
分别实现顺序栈和链栈的抽象数据类型定义，完成栈的基本操作：初始化栈、检查栈是否为空、清空栈、入栈、退栈、取栈顶元素。 分别实现循环队列和链队列的抽象数据类型定义，完成队列的基本操作：初始化队列、检查...
Acwing-基础算法-第二章-数据结构
03-24
马上就快要蓝桥杯了，基础算法部分是肯定看不完了，还是觉得看过的多加练习，把看过的练熟，理解思路，也能取到不错的成绩！！！
基础算法----线性表和栈，队列
04-03
初学者，分享一下自己的学习情况，
AcWing数据结构
柒月栗子的博客
12-31 114
AcWing算法基础课和提高课关于数据结构的部分（持续更新ing
acwing算法基础之数据结构--堆算法
YMWM_的博客
11-05 357
手写堆
AcWing算法基础课-数据结构-队列、单调栈、单调队列、KMP
qq_51217536的博客
01-26 207
AcWing算法基础课学习笔记六（队列、单调栈、单调队列、KMP）
【ACWing 算法基础】单调队列
m0_51139226的博客
08-01 177
解析动画解题思路解决队首已经出窗口的问题;解决队尾与当前元素a[i]不满足单调性的问题;将当前元素下标加入队尾;如果满足条件则输出结果;
acwing算法基础课-第二章 数据结构
偶然路过的帅小伙z的博客
04-19 387
链表与邻接表：树与图的存储 栈与队列：单调队列、单调栈 kmp Trie 并查集 堆 Hash表
AcWing: 单调队列
qq_52097561的博客
03-10 290
c++ 单调队列 单调栈
acwing算法基础课-数据结构部分
fang 0 jun的博客
05-17 368
第二章：数据结构 2-1-1 单链表 （因为传统链式存储需要大量使用New函数，会带来大量时间上的开销，所以我们用数组模拟） （通常情况下，数据规模1e6） #include<iostream> using namespace std; const int N=100010; //head表示头结点的下标 //e[i]表示结点i的值 //ne[i]表示结点i的next指针是多少 //idx存储当前已经用到了哪个点 int head,e[N],ne[N],idx; //初始化 void init(
Acwing 第二章模板及详解（数据结构）
weixin_64393298的博客
02-04 1068
一、链表与邻接表：树与图的存储 二、栈与队列：单调队列、单调栈 三、kmp 四、Trie 五、并查集 六、堆 七、Hash表 单链表 // head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点 int head, e[N], ne[N], idx; // 初始化 void init() { head = -1; idx = 0; } // 在链表头插入一个数a void insert(int a) { e[idx] = a...
acwing 算法基础课数据结构
08-19
第四章是关于贪心算法的内容。贪心算法是一种基于贪心策略的算法思想，它在每一步选择中都采取当前状态下最优的选择，以期望达到全局最优解。 在这一章节中，你将学习到以下内容： 1. 贪心算法的基本思想和特点； 2...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

YMWM_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值