【C++ STL之队列和栈详解】
目录
- 一.stack栈
-
- 1.简介
- 2.包含头文件及初始化
- 3.基本操作
- 4.示例（判断回文字符串）
- 二.queue队列
-
- 1.简介
- 2.包含头文件及初始化
- 3.基本操作
- 4.队列模拟
- 三.deque双端队列
-
- 1.简介
- 2.包含头文件及初始化
- 3.基本操作
- 4.排序
- 四.priority_queue优先队列
-
- 1.简介
- 2.头文件及初始化
- 3.基本操作
- 4.设置优先级（排序）
- 5.结构体(或自定义)优先级设置
- 6.存储特殊类型的优先级
一.stack栈
1.简介
在C++的STL（Standard Template Library）中，stack（栈）是一个非常有用的容器适配器。它提供了一种后进先出（LIFO）的数据结构，类似于现实生活中的堆栈。本文将详细介绍C++ STL中stack的使用方法和一些常见操作。
2.包含头文件及初始化
#include 3.基本操作
| 代码 | 含义 |
|---|---|
| stk.push() | 压栈，增加元素 |
| stk.pop() | 移除栈顶元素 |
| stk.top() | 取得栈顶元素（但不删除） |
| stk.empty() | 检测栈内是否为空，空为真 |
| stk.size() | 返回stack内元素的个数 |
接下来将提供一些代码来帮助理解
myStack.push(10); // 入栈
myStack.pop(); // 出栈
if (!myStack.empty()) {
int topElement = myStack.top(); // 访问栈顶元素
}
if (myStack.empty()) {
// 栈为空
}
int stackSize = myStack.size(); // 获取栈的大小
4.示例（判断回文字符串）
#include 二.queue队列
1.简介
在C++的STL（Standard Template Library）中，queue（队列）是一个常用的容器适配器。它提供了一种先进先出（FIFO）的数据结构，类似于现实生活中的排队。本文将详细介绍C++ STL中queue的使用方法和一些常见操作。
2.包含头文件及初始化
（1）可以使用以下方式声明和初始化一个queue对象：
#include （2）也可以使用已有的容器初始化队列对象：
std::list<int> myList = {1, 2, 3, 4, 5};
std::queue<int, std::list<int>> myQueue(myList); // 使用list初始化队列
3.基本操作
| q.front() | 返回队首元素 |
| q.back() | 返回队尾元素 |
| q.push() | 尾部添加一个元素副本 进队 |
| q.pop() | 删除第一个元素 出队 |
| q.size() | 返回队列中元素个数，返回值类型unsigned int |
| q.empty() | 判断是否为空，队列为空，返回true |
接下来将提供一些代码来帮助理解
myQueue.push(10); // 入队
myQueue.pop(); // 出队
if (!myQueue.empty()) {
int frontElement = myQueue.front(); // 访问队首元素
int backElement = myQueue.back(); // 访问队尾元素
}
if (myQueue.empty()) {
// 队列为空
}
int queueSize = myQueue.size(); // 获取队列的大小
4.队列模拟
使用q[ ]数组模拟队列
hh表示队首元素的下标，初始值为0
tt表示队尾元素的下标，初始值为-1，表示刚开始队列为空
队列模拟示例
下面是一个使用queue模拟排队系统的示例程序。
#include 三.deque双端队列
1.简介
在C++的STL（Standard Template Library）中，deque（双端队列）是一个非常有用的容器。deque是一个双向开口的连续线性空间，可以在两端进行高效的插入和删除操作。本文将详细介绍C++ STL中deque的特点、使用方法和一些常见操作。
特点
deque具有以下特点：
双向开口：deque可以在两端进行高效的插入和删除操作，即在队首和队尾都可以进行操作。
动态扩展：deque的内部实现使用了分段连续线性空间，可以动态扩展以适应元素的增加。
随机访问：deque支持随机访问，可以通过下标访问元素。
2.包含头文件及初始化
（1）头文件
#include （2）可以使用以下方式声明和初始化一个deque对象：
std::deque<int> myDeque; // 声明一个空的整数双端队列
（3）也可以使用已有的容器初始化双端队列对象：
std::vector<int> myVector = {1, 2, 3, 4, 5};
std::deque<int> myDeque(myVector.begin(), myVector.end()); // 使用vector初始化双端队列
3.基本操作
| 代码 | 含义 |
|---|---|
| push_back(x)/push_front(x) | 把x压入后/前端 |
| back()/front() | 访问(不删除)后/前端元素 |
| pop_back() pop_front() | 删除后/前端元素 |
| erase(iterator it) | 删除双端队列中的某一个元素 |
| erase(iterator first,iterator last) | 删除双端队列中[first,last）中的元素 |
| empty() | 判断deque是否空 |
| size() | 返回deque的元素数量 |
| clear() | 清空deque |
接下来将提供一些代码来帮助理解
myDeque.push_back(10); // 在队尾插入元素
myDeque.push_front(20); // 在队头插入元素
myDeque.pop_back(); // 删除队尾元素
myDeque.pop_front(); // 删除队头元素
if (!myDeque.empty()) {
int frontElement = myDeque.front(); // 访问队头元素
int backElement = myDeque.back(); // 访问队尾元素
}
if (myDeque.empty()) {
// 双端队列为空
}
int dequeSize = myDeque.size(); // 获取双端队列的大小
int element = myDeque[2]; // 访问下标为2的元素
对于erase（）
deque<int> myDeque = {1, 2, 3, 4, 5};
deque<int>::iterator it = myDeque.begin() + 2; // 指向第三个元素的迭代器
myDeque.erase(it); // 删除第三个元素
deque<int> myDeque = {1, 2, 3, 4, 5};
deque<int>::iterator first = myDeque.begin() + 1; // 指向第二个元素的迭代器
deque<int>::iterator last = myDeque.begin() + 4; // 指向第五个元素的迭代器
myDeque.erase(first, last); // 删除第二个到第四个元素
4.排序
#include 另外，如果需要按照自定义的排序规则进行排序，可以使用sort()函数的第三个参数，传入一个可调用对象（函数、函数指针、函数对象、lambda 表达式等）来定义排序规则。
sort(numbers.begin(), numbers.end(), [](int a, int b) {
return a > b; // 按降序排序
});
也可以如下
//从小到大
sort(d.begin(),d.end())
//从大到小排序
sort(q.begin(), q.end(), greater<int>());//deque里面的类型需要是int型
sort(q.begin(), q.end(), greater());//高版本C++才可以用
四.priority_queue优先队列
1.简介
在C++的STL（Standard Template Library）中，优先队列（priority_queue）是一个非常有用的容器适配器。它提供了一种特殊的队列，其中的元素按照一定的优先级进行排序和访问。本文将详细介绍C++ STL中优先队列的使用方法和一些常见操作。
2.头文件及初始化
（1）包含头文件
#include （2）可以使用以下方式声明和初始化一个优先队列对象：
priority_queue<int> myQueue; // 声明一个空的整数优先队列
（3）也可以使用已有的容器初始化优先队列对象：
vector<int> myVector = {1, 2, 3, 4, 5};
priority_queue<int> myQueue(myVector.begin(), myVector.end()); // 使用vector初始化优先队列
3.基本操作
| 代码 | 含义 |
|---|---|
| push() | 入队 |
| pop() | 堆顶（队首）元素出队 |
| size() | 队列元素个数 |
| empty() | 是否为空 |
| 注意没有clear()！ | |
| 优先队列只能通过top()访问队首元素（优先级最高的元素） |
4.设置优先级（排序）
priority_queue<int, vector<int>, less<int> >pq;
//最后两个>之间要有空格
解释：
int：表示队列中元素的类型，这里是整数类型。
vector：表示底层容器的类型，这里使用vector作为底层容器。
less：表示元素的比较函数对象，用于定义元素的优先级。
less:是一个函数对象，用于按照升序对元素进行比较。
priority_queue<int,vector<int>, greater<int> > pq;
//此为降序
自定义排序：
struct MyComparator {
bool operator()(int a, int b) {
// 自定义排序规则，按照元素的绝对值进行降序排序
return abs(a) < abs(b);
}
};
int main() {
priority_queue<int, vector<int>, MyComparator> pq;
pq.push(10);
pq.push(-5);
pq.push(8);
pq.push(-3);
while (!pq.empty()) {
cout << pq.top() << " ";
pq.pop();
}
return 0;
}
5.结构体(或自定义)优先级设置
//要排序的结构体（存储在优先队列里面的）
struct node
{
int x,y;
};
//定义的比较结构体
//注意：cmp是个结构体
struct cmp
{//自定义堆的排序规则
bool operator()(const node& a,const node& b)
{
return a.x>b.x;//从堆底到堆顶 降序排序
}//如果要升序改变不等号方向就好
};
//初始化定义，
priority_queue<node,vector<node>,cmp >pq;
或者不用写关的参数，直接在node里面写
struct node
{
int x,y;
friend bool operator<(node a,node b)
{//为两个结构体参数，结构体调用一定要写上friend
return a.x>b.x;//按x从小到大排
}
};
6.存储特殊类型的优先级
存储pair类型
规则：默认先对pair的first进行降序排序，然后再对second降序排序
对first先排序，大的排在前面，如果first元素相同，再对second元素排序，保持大的在前面。
int main()
{
priority_queue<pair<int,int> >q;
q.push({1,2});
q.push({1,3});
q.push(make_pair(2,3));
while(!q.empty())
{
cout<<q.top().first<<" "<<q.top().second<<endl;
q.pop();
}
return 0;
}
结果
2 3
1 3
1 2