【C++ STL之队列和栈详解】

最新推荐文章于 2024-04-27 16:49:54 发布

马户一口吞不下又鸟

最新推荐文章于 2024-04-27 16:49:54 发布

阅读量2.3k

点赞数 20

文章标签： c++ 算法开发语言

本文链接：https://blog.csdn.net/iluuoip/article/details/132289453

版权

一.stack栈

1.简介

在C++的STL（Standard Template Library）中，stack（栈）是一个非常有用的容器适配器。它提供了一种后进先出（LIFO）的数据结构，类似于现实生活中的堆栈。本文将详细介绍C++ STL中stack的使用方法和一些常见操作。

2.包含头文件及初始化

#include <stack>
//声明
stack<int>stk1;
stack<string>stk2;
stack<ListNode*>stk3;

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 <iostream>
#include <stack>
#include <string>

bool isPalindrome(const std::string& str) {
    std::stack<char> charStack;
    int length = str.length();
    // 将字符串的前半部分入栈
    for (int i = 0; i < length / 2; i++) {
        charStack.push(str[i]);
    }
    // 判断字符串的后半部分和栈中的元素是否相等
    for (int i = (length + 1) / 2; i < length; i++) {
        if (str[i] != charStack.top()) {
            return false;
        }
        charStack.pop();
    }
    return true;
}
int main() {
    std::string str;
    std::cout << "请输入一个字符串: ";
    std::cin >> str;
    if (isPalindrome(str)) {
        std::cout << "是回文字符串" << std::endl;
    } else {
        std::cout << "不是回文字符串" << std::endl;
    }
    return 0;
}

二.queue队列

1.简介

在C++的STL（Standard Template Library）中，queue（队列）是一个常用的容器适配器。它提供了一种先进先出（FIFO）的数据结构，类似于现实生活中的排队。本文将详细介绍C++ STL中queue的使用方法和一些常见操作。

2.包含头文件及初始化

（1）可以使用以下方式声明和初始化一个queue对象：

#include <queue>
std::queue<int> myQueue; // 声明一个空的整数队列

（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 <iostream>
#include <queue>
#include <string>
using namespace std;
void simulateQueue() {
    queue<string> waitingQueue;
    string customerName;
    while (true) {
        cout << "请输入顾客姓名（输入exit退出）: ";
        cin >> customerName;
        if (customerName == "exit") {
            break;
        }
        waitingQueue.push(customerName);
        cout << customerName << " 已加入排队队列" <<endl;
    }
    cout << "排队队列中的顾客如下：" << endl;
    while (!waitingQueue.empty()) {
        cout << waitingQueue.front() << endl;
        waitingQueue.pop();
    }
}
int main() {
    simulateQueue();
    return 0;
}

三.deque双端队列

1.简介

在C++的STL（Standard Template Library）中，deque（双端队列）是一个非常有用的容器。deque是一个双向开口的连续线性空间，可以在两端进行高效的插入和删除操作。本文将详细介绍C++ STL中deque的特点、使用方法和一些常见操作。
特点
deque具有以下特点：
双向开口：deque可以在两端进行高效的插入和删除操作，即在队首和队尾都可以进行操作。
动态扩展：deque的内部实现使用了分段连续线性空间，可以动态扩展以适应元素的增加。
随机访问：deque支持随机访问，可以通过下标访问元素。

2.包含头文件及初始化

（1）头文件

#include <deque>

（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 <iostream>
#include <deque>
#include <algorithm>
int main() {
    deque<int> numbers = {5, 2, 4, 1, 3};
    sort(numbers.begin(), numbers.end());
    for (int num : numbers) {
        cout << num << " ";
    }
    return 0;
}

另外，如果需要按照自定义的排序规则进行排序，可以使用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 <queue>

（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

马户一口吞不下又鸟

关注

20
点赞
踩
44

收藏

觉得还不错? 一键收藏
打赏
6
评论
【C++ STL之队列和栈详解】

在C++的STL（Standard Template Library）中，stack（栈）是一个非常有用的容器适配器。它提供了一种后进先出（LIFO）的数据结构，类似于现实生活中的堆栈。本文将详细介绍C++ STL中stack的使用方法和一些常见操作。在C++的STL（Standard Template Library）中，queue（队列）是一个常用的容器适配器。它提供了一种先进先出（FIFO）的数据结构，类似于现实生活中的排队。本文将详细介绍C++ STL中queue的使用方法和一些常见操作。
复制链接

扫一扫