stack和queue

最新推荐文章于 2024-05-09 17:00:00 发布

高手很帅

最新推荐文章于 2024-05-09 17:00:00 发布

阅读量364

点赞数

文章标签： c++ 容器

本文链接：https://blog.csdn.net/Casper_AZ/article/details/127219545

版权

6、priority_queue常用接口使用

7、容器适配器

什么是适配器

1、stack的介绍

stack文档介绍

1、stack类是容器适配器，他给予程序员栈的功能，特别是FILO（先进后出）数据结构。

2、stack类模板表现为底层容器的包装器，只提供特定函数集合。元素从特定容器的尾部推弹元素

3、stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，只要这些容器支持：

empty	判空操作
back	获取尾部元素
push_back	尾插
pop_back	尾删

4、标准容器中，vector、list、deque都满足要求，在没有指明用什么底层容器的情况下，stack默认用deque作为底层容器。

2、stack常用接口使用

添加头文件 #include<stack> 使用

stack() ：构造空栈

stack<int> s1;//构建一个空栈

//直接用deque构造s2
deque<int> dq(3, 5);
stack<int> s2(dq);

//通过将底层容器设置成vector
//然后利用vector初始化
vector<int> v(4, 5);
stack<int, vector<int>> s3(v);

//将底层容器设置成list
//再利用list初始化
list<int> l(5, 5);
stack<int, list<int>>s4(l);

empty：判断栈是否为空

stack<int> s5;
s5.push(3);
s5.push(2);
s5.push(1);
if (s5.empty())
	cout << "空栈" << endl;
else
	cout << "非空" << endl;

size：返回栈中数据个数

stack<int> s5;
s5.push(3);
s5.push(2);
s5.push(1);
cout << s5.size() << endl;//3

top ：返回栈顶（最后一个入栈）元素的引用

stack<int> s5;
s5.push(3);
s5.push(2);
s5.push(1);
cout << s5.top() << endl;//1

push：将数据入栈

stack<int> s5;
s5.push(3);
s5.push(2);
s5.push(1);

pop ：删除栈顶元素

stack<int> s1;
s1.push(1);
s1.push(2);
s1.push(3);
s1.pop();//删除3

swap：交换两个栈的数据

stack<int> s1, s2;
s1.push(1);
s1.push(2);
s2.push(3);
s2.push(4);
s1.swap(s2);

3、queue的介绍

queue文档介绍

1、queue类是容器适配器，它给予程序员队列的功能，是 FIFO （先进先出）数据结构。

2、queue类模板底层是底层容器的包装器，只提供特定的函数集合。数据从队尾进队头出。

3、queue的底层容器可以是任何标准容器类，也可以是其他专门设计的容器类。但该底层容器蓄满足以下功能：

empty	判空操作
size	返回有效数据个数
front	返回首元素的引用
back	返回最后一个元素的引用
push_back	尾插
pop_front	头删

4、标准容器list和deque满足作为queue底层容器的条件，默认情况下，使用deque作为queue的底层容器。

4、queue常用接口使用

包含头文件 #include<queue>

queue ：构造空的队列

queue<int> q1;//构造一个空队列

//利用deque构造队列
deque<int> dq(3, 4);
queue<int> q2(dq);

//利用list构造队列
list<int> l(2, 3);
queue<int, list<int>> q3(l);

empty ：判断队列是否为空

deque<int> dq(3, 4);
queue<int> q2(dq);
if (q2.empty())
	cout << "空队列" << endl;
else
	cout << "非空" << endl;

size：返回队列中有效数据的个数

deque<int> dq(3, 4);
queue<int> q2(dq);
cout << q2.size() << endl;//3

front ：返回队头数据的引用

deque<int> dq(3, 4);
queue<int> q2(dq);
cout << q2.front() << endl;//4

back ：返回队尾数据的引用

deque<int> dq(3, 4);
queue<int> q2(dq);
cout << q2.back() << endl;//4

push ：从队尾插入数据

queue<int> q1;
q1.push(1);
q1.push(2);

pop ：从队头删除数据

queue<int> q1;
q1.push(1);
q1.push(2);
q1.pop();//删除1

swap：交换两个队列的数据

queue<int> q1, q2;
q1.push(1);
q1.push(2);
q2.push(3);
q2.push(4);
q1.swap(q2);

5、priority_queue的介绍

priority_queue文档介绍

1、priority_queue是容器适配器，它提供常数次的最大元素（默认）查找。

2、用户可提供Compare更改顺序，例如使用greater<T>将最小元素置于队头位置。

3、优先级队列默认是从大到小排列，默认就是大堆。

4、优先级队列的底层容器可以是标准容器类模板，但必须满足一下功能

empty()	检测容器是否为空
size()	返回容器中有效元素的个数
front()	返回容器中第一个元素的引用
push_back()	在容器尾部插入元素
pop_back()	删除容器尾部元素

5、vector和deque都满足上面的条件，默认情况下，priority_queue使用vector作为底层容器。

6、priority_queue常用接口使用

包含头文件 #include<queue> 使用

priority_queue() ：构造一个空队列

//构造空的优先级队列
priority_queue<int> pq1;

//利用vector的数据构造优先级队列
vector<int> vt{ 1,2,3,4,5 };
priority_queue<int> pq2(vt.begin(), vt.end());

//利用deque的数据构造优先级队列
deque<int> dq{ 4,5,6 };
priority_queue<int> pq3(dq.begin(), dq.end());

//底层容器用list的优先级队列
priority_queue<int, list<int>> pq4;

//通过设置第三个参数就能实现从小到大排序
//由于参数不能跳着给，所以第二个参数也要写
priority_queue<int, vector<int>, greater<int>> pq5(vt.begin(), vt.end());

empty：检查优先级队列是否为空，空返回true，否则false

vector<int> vt{ 1,2,3,4,5 };
priority_queue<int> pq2(vt.begin(), vt.end());
if (pq2.empty())
	cout << "空" << endl;
else
	cout << "非空" << endl;

size ：返回优先级队列有效数据个数

vector<int> vt{ 1,2,3,4,5 };
priority_queue<int> pq2(vt.begin(), vt.end());
cout << pq2.size() << endl;//5

top ：返回优先级队列队首元素的引用

vector<int> vt{ 1,2,3,4,5 };
priority_queue<int> pq2(vt.begin(), vt.end());
cout << pq2.top() << endl;//5

push ：往优先级队列里插入数据

vector<int> vt{ 1,2,3,4,5 };
priority_queue<int> pq2(vt.begin(), vt.end());
pq2.push(6);//插入6
//由于默认是大堆，所以插入6后队首元素就是6
cout << pq2.top() << endl;//6

pop ：删除优先级队列队首元素

vector<int> vt{ 1,2,3,4,5 };
priority_queue<int> pq2(vt.begin(), vt.end());
pq2.pop();//删除最大值5
cout << pq2.top() << endl;//4

swap ：交换两个优先级队列的数据

vector<int> vt{ 1,2,3,4,5 };
priority_queue<int> pq2(vt.begin(), vt.end());
deque<int> dq{ 4,5,6 };
priority_queue<int> pq3(dq.begin(), dq.end());
pq2.swap(pq3);