【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 
//声明
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 
#include 
#include 

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 
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 
#include 
#include 
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 

(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 
#include 
#include 
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 

(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

你可能感兴趣的:(c++,算法,开发语言)