C++ 队列!还是要从 STL 中的说起……
1. 前言
队列和栈一样,都是受限的数据结构。
队列遵循先进先出
的存储原则,类似于一根水管,水从一端进入,再从另一端出去。进入的一端称为队尾
,出去的一端称为队头
。
队列有 2
个常规操作:
- 入队:进入队列,数据总是从队尾进入队列。
- 出队:从队列中取出数据,数据总是从队头出来。
本文将先从STL
的队列说起,然后讲解如何自定义队列。
2. STL 中的队列
STL
的队列有:
queue(普通队列)
。priority_queue(优先队列)
。deque(双端队列)
。
2.1 queue(普通队列)
queue
是一个适配器对象,是对deque
组件进行改造后的伪产品,可以在源代码中看出端倪。
template<typename _Tp, typename _Sequence = deque<_Tp> >
class queue{
//……
}
构建queue
时需要 2
个类型参数:
_Tp
:存储类型说明。_Sequence
:真正的底层存储组件,默认是deque
。使用时,开发者可以根据需要指定其它的存储组件。
queue
类中提供了几个常规操作方法:
方法名 | 功能说明 |
---|---|
back() |
返回最后一个元素 |
empty() |
如果队列空则返回真 |
front() |
返回第一个元素 |
pop() |
删除第一个元素 |
push() |
在末尾加入一个元素 |
size() |
返回队列中元素的个数 |
操作实例:
#include <iostream>
#include <queue>
using namespace std;
int main(int argc, char** argv) {
//创建并初始化队列
queue<int> myQueue;
//向队列添加数据
for(int i=0; i<5; i++) {
myQueue.push(i);
}
cout<<"查看队尾的数据"<<myQueue.back()<<endl;
cout<<"看队列的第一个数据"<<myQueue.front()<<endl;
//获取到队列的大小
int size=myQueue.size();
//所有数据出队列
for(int i=0; i<size; i++) {
cout<<myQueue.front()<<endl;
myQueue.pop();
}
cout<<"列是否为空:"<<myQueue.empty()<<endl;
return 0;
}
输出结果:
在上述创建queue
时也可以指定list
作为底层存储组件。
queue<int,list<int> > myQueue;
改变底层依赖组件,对业务层面的实现不会产生任何影响 ,这也是适配器设计模式的优点。
2.2 Priority Queues
从优先队列中删除数据时,并不一定是按先进先出
的原则,而是遵循优先级法则,优先级高的数据先出队列,与数据的存储顺序无关。类似于现实生活中的VIP
客户一样。
优先队列的常规方法:
方法 | 功能说明 |
---|---|
empty() |
如果优先队列为空,则返回真 |
pop() |
删除第一个元素 |
push() |
加入一个元素 |
size() |
返回优先队列中拥有的元素的个数 |
top() |
返回优先队列中有最高优先级的元素 |
创建并初始化优先队列:
使用之前,先查阅 priority_queue
的源代码。
template<typename _Tp, typename _Sequence = vector<_Tp>,typename _Compare = less<typename _Sequence::value_type> >
class priority_queue
{
//……
}
从源代码可知,优先队列属于容器适配器组件,本身并不提供具体的存储方案,使用时,需要指定一个容器对象
用于底层存储(默认是 vector
容器)。除此之外,还需要一个能对数据进行优先级判定的对象。
当存储的数据是基本类型时,可以使用内置的函数对象进行比较。
//升序队列
priority_queue <int,vector<int>,greater<int> > q;
//降序队列
priority_queue <int,vector<int>,less<int> > q_;
greater
和less
是内置的两个函数对象。
如果是对自定义类型进行比较,则需要提供自定义的比较算法,可以通过如下的 2
种方式提供:
lambda
函数。
auto cmp = [](pair<int, int> left, pair<int, int> right) -> bool { return left.second > right.second; };
priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(cmp)> pri_que(cmp);
- 自定义函数对象。要求函数对象中重写
operator()
函数,如此,对象便能如函数一样使用。
struct com_{
bool operator()(const pair<int, int>& left, const pair<int, int>& right) {
return left.second > right.second;
}};
priority_queue<pair<int,int>,vector<pair<int, int>>,com_> pri_que2;
操作实例:
实例功能要求:使用优先队列存储运算符,获取运算符时,按运算符的优先级出队。
#include <iostream>
#include <queue>
using namespace std;
//运算符对象
struct Opt {
//运算符名
char name;
//运算符的优先级
int jb;
void desc() {
cout<<name<<":"<<jb<<endl;
}
};
//函数对象,提供优先级队列的比较法则
struct com {
bool operator()(const Opt& opt1, const Opt& opt2) {
return opt1.jb<opt2.jb;
}
};
int main(int argc, char** argv) {
priority_queue<Opt ,vector<Opt>,com> opt_que;
//添加运算符
Opt opt= {'+',1} ;
opt_que.push(opt);
opt= {'*',2} ;
opt_que.push(opt);
opt= {'(',3} ;
opt_que.push(opt);
opt= {')',0} ;
opt_que.push(opt);
//出队列
int size= opt_que.size();
for(int i=0; i<size; i++) {
Opt tmp=opt_que.top();
opt_que.pop();
tmp.desc();
}
cout<<"队列是否为空:"<<opt_que.empty()<<endl;
return 0;
}
输出结果:
2.3 deque
前面的queue
对象本质是在deque
的基础上进行重新适配之后的组件,除此之外,STL
中的stack
也是……
deque
也称为双端队列,在两端都能进行数据的添加、删除。可以认为deque
是一个伸缩性很强大的基础功能组件,对其进行某些功能的屏蔽或添加,便能产生新组件。
deque
的相关方法如下:
push_back()
:在队尾添加数据。pop_back()
:数据从队尾出队列。push_front()
:在队头添加数据。pop_front()
:数据从队头出队列。
如果只允许使用push_back()
和pop_back()
或push_front()
和pop_front()
方法,就可以模拟出栈的存储效果。
类似的,如果禁用pop_back()
和push_front()
则可以模拟出普通队列的存储效果……
可能会问,为什么选择deque
作为基础组件,难道它有什么先天性优势吗?
这个就需要从它的物理结构说起。
deque
物理结构中的基本存储单位称为段,段是一个连续的可存储 8
个数据的顺序区域。一个deque
对象由很多段组成,段与段在物理空间上并不相邻,而是通过一个中央控制段存储其相应地址。
deque
具有顺序存储的查询性能优势也具有链式存储的插入、删除方面的性能优势。因为它在物理结构上完美地融合了顺序存储思想(局部)和链式存储思想(整体)。
在一个段上进行数据查询是很快的,即使有插入和删除操作也只会对本段的性能有影响,而不会拖累整体性能。
操作实例:
#include <iostream>
#include <vector>
#include <deque>
using namespace std;
int main(int argc, char *argv[]) {
int ary[5] = {1, 2, 3, 4, 5};
//使用数组初始化 vector
vector<int> vec( &ary[0], &ary[4]+1 );
//使用 vector 初始化双端队列
deque<int> myDeque( vec.begin(), vec.end() );
//队头插入数据
myDeque.push_front( 0 );
//队尾插入数据
myDeque.push_back( 6 );
cout<<"查看队头数据 : "<<myDeque.front()<<endl;
cout<<"查看队尾数据: "<<myDeque.back()<<endl;
//双端队列支持迭代器查询
deque<int>::iterator iter = myDeque.begin();
while( iter != myDeque.end() ) {
cout<<*(iter++)<<' ';
}
cout<<endl;
//双端队列支持下标访问方式
cout<<"a[3] = "<<myDeque[3] << endl;
//支持迭代器删除
myDeque.erase( myDeque.begin() );
//删除头部删除
myDeque.pop_front();
// 删除尾部元素
myDeque.pop_back();
cout<<"查看队头数据: "<<myDeque.front()<<endl;
cout<<"查看队尾数据: "<<myDeque.back()<<endl;
return 0;
}
执行后输出结果:
3. 自定义队列
队列有 2 种实现方案:
- 顺序实现,基于数组的实现方案。
- 链表实现,基于链表的实现方案。
3.1 顺序实现
顺序实现底层使用数组作为具体存储容器。实现之初,需要创建一个固定大小的数组。
3.1.1 思路
数组是开发式的存储容器,为了模拟队列,可以通过 2
个指针用来限制数据的存和取:
front
:指向队头的指针,用来获取队头数据。总是指向最先添加的数据。rear
:指向队尾的指针,用来在队尾添加数据。
初始,front
和rear
指针可以指向同一位置,可以是下标为0
位置。如下图所示:
可以根据front
和rear
所指向位置是否相同,而判断队列是否为空。
如果 front==rear:
表示当前队列是空的
入队操作:
- 将数据存储在
rear
所指向位置,再把rear
向右边移动一个位置(rear
总是指向下一个可用的位置)。
- 当
rear
超出数组的边界,即下标为数组的长度时,表示队列已经满了。
如果 rear==数组长度
表示队列已经满了
出队操作:
出队操作可以有 2
个方案。
front
固定在下标为0
的位置,从队列删除一个数据后,后续数据向前移动一位,并把rear
指针向左移动一位。如下图是删除数据1
后的演示图:
这种方案的弊端是,每删除一个数据,需要后续数据整体向左移动,时间复杂度为O(n)
,性能偏低。
- 从
front
位置处提取数据后,front
指针向右边移动。
以front
位置为队头,而不是以数组的绝对位置0
为队头。这种方案的优势很时显,时间复杂度为O(1)
。
但会出现假溢出
的现象,如上图示,删除数据1
后,留下了一个可用的空位置,因rear
指针是向右移动的,并不知前面有空的位置,从而也无法使用此空位置。
针对于这种情况,可以让rear
指针在超过下标界限后,重头再开始定位,这样的队列称为循环队列。
前文说过,当front
和rear
指针相同时,认定队列为空。在循环队列,当入队的速度快于出队速度时,rear
指针是可以追上front
指针的。如下图所示:
这时队列为满负荷状态。也就是说,front
等于rear
时队列有可能是空的也有可能是满的。
可以使用 2
种方案解决这个问题:
- 计数器方案。使用计数器记录队列中的实际数据个数。当
num==0
时队列为空状态,当num==size
时队列为满状态。 - 留白方案:存储数据时,从
rear+1
位置开始,而不是存储在rear
位置。或者说下标为0
的位置空出来。
这样,当rear+1
等于front
时,可判定队列为满状态。
注意,在获取队头数据时,需要先把front
向右移一位。
3.1.2 编码实现
循环队列类(留白方案):
class MyQueue {
private:
//数组
int *queue;
int front;
int rear;
int size;
public:
//构造函数
MyQueue(int queueSize=10):size(queueSize),front(0),rear(0) {
this->queue=new int[queueSize];
}
//析构函数
~ MyQueue() {
delete[] queue;
}
//队列是否为空
bool isEmpty() {
return this->front==this->rear;
}
//数据入队列
bool push_back(int data) {
//需要判断队列是否有空位置
if (((this->rear+1)%this->size)!=this->front) {
//获取当前可存储位置
this->rear=(this->rear+1) % this->size;
//存储数据
this->queue[this->rear]=data;
return true;
}
return false;
}
//数据出队列
bool pop_front(int& data) {
//队列不能为空
if (this->rear!=this->front) {
//头指针向右移动
this->front=(this->front+1) % this->size;
data=this->queue[this->front];
return true;
}
return false;
}
//查看队头数据
bool get_front(int & data) {
//队列不能为空
if (this->rear!=this->front) {
//头指针向右移动
int idx=(this->front+1) % this->size;
data=this->queue[idx];
return true;
}
return false;
}
};
测试队列:
#include <iostream>
using namespace std;
int main(int argc, char *argv[]) {
MyQueue myQueue(5);
//向队列中压入 4 个数据,注意,有一个位置是空着的
for(int i=0; i<5; i++) {
myQueue.push_back(i);
}
int data;
myQueue.get_front(data);
cout<<"队头数据:"<<data<<endl;
//队列已经满,测试是否还能压入数据
int data_=5;
bool is= myQueue.push_back(data_);
if(is)
cout<<"压入成功"<<endl;
else
cout<<"压入失败"<<endl;
//把队列中的所有数据删除
int tmp;
for(int i=0; i<4; i++) {
is= myQueue.pop_front(tmp);
if(is)
cout<<tmp<<endl;
}
}
输出结果:
3.2 链式实现
链式实现队列时,数据可以从头部插入然后从尾部删除,或从尾部插入再从头部删除。本文使用尾部插入,头部删除方案。
- 链表实现时,需要头指针也需要尾指针。初始,都为
NULL
。
- 链式实现的过程简单清晰,就是在单链表上的数据添加和删除操作,具体细节这里就不再废话,直接上代码:
链式实现的流程简单清晰,这里就不再废话,直接上代码:
#include <iostream>
using namespace std;
//链表的结点类型
struct QueueNode {
int data;
QueueNode* next;
QueueNode() {
this->next=NULL;
};
};
class MyQueue_ {
private:
//数组
QueueNode* front;
QueueNode* rear;
public:
//构造函数
MyQueue_() {
this->front=NULL;
this->rear=NULL;
}
//析构函数
~ MyQueue_() {
QueueNode* p, *q;
p=front;
while(p) {
q=p;
p=p->next;
delete q;
}
front=NULL;
rear=NULL;
}
//队列是否为空
bool isEmpty() {
return this->front==NULL && this->rear==NULL;
}
//数据入队列
bool push_back(int data) {
//新结点
QueueNode* p=new QueueNode();
if(p) {
//申请结点成功
p->data=data;
if(rear) {
rear->next=p;
rear=p;
} else
front=rear=p;
return true;
} else
return false;
}
//数据出队列
bool pop_front(int& data) {
QueueNode* p;
if(!isEmpty()) {
//判断队列是否为空
p=front;
data=p->data;
front=front->next;
if(!front)
rear=NULL;
delete p;
return true;
}
return false;
}
//查看队头数据
bool get_front(int & data) {
if(!isEmpty()) {
data=front->data;
return true;
} else
return false;
}
};
int main(int argc, char *argv[]) {
MyQueue_ myQueue;
//向队列中压入 4 个数据,注意,有一个位置是空着的
for(int i=0; i<5; i++) {
myQueue.push_back(i);
}
int data;
myQueue.get_front(data);
cout<<"队头数据:"<<data<<endl;
//队列已经满,测试是否还能压入数据
int data_=5;
bool is= myQueue.push_back(data_);
if(is)
cout<<"压入成功"<<endl;
else
cout<<"压入失败"<<endl;
//把队列中的所有数据删除
int tmp;
for(int i=0; i<4; i++) {
is= myQueue.pop_front(tmp);
if(is)
cout<<tmp<<endl;
}
}
输出结果:
4. 总结
本文讲解了STL
中的队列组件,以及如何通过顺序表和链表模拟队列。
本文同时被收录到"编程驿站"公众号。
C++ 队列!还是要从 STL 中的说起……的更多相关文章
- 手写队列以及stl中队列的使用
一,手写队列. struct queue { ; ,rear=,a[maxn]; void push(int x) { a[++rear]=x; } void pop() { first++; } i ...
- STL中的单向队列queue
转载自:http://blog.csdn.net/morewindows/article/details/6950917 stl中的queue指单向队列,使用时,包含头文件<queue>. ...
- STL中队列(queue)的使用方法
STL 中队列的使用(queue) 基本操作: push(x) 将x压入队列的末端 pop() 弹出队列的第一个元素(队顶元素),注意此函数并不返回任何值 front() 返回第一个元素(队顶元素) ...
- STL中的优先级队列priority_queue
priority_queue(queue类似)完全以底部容器为根据,再加上二叉堆(大根堆或者小根堆)的实现原理,所以其实现非常简单,缺省情况下priority_queue以vector作为底部容器.另 ...
- 用数组模拟STL中的srack(栈)和queue(队列)
我们在理解stack和queue的基础上可以用数组来代替这两个容器,因为STL中的stack和queue有可能会导致程序运行起来非常的慢,爆TLE,所以我们使用数组来模拟他们,不仅可以更快,还可以让代 ...
- 深入了解STL中set与hash_set,hash表基础
一,set和hash_set简介 在STL中,set是以红黑树(RB-Tree)作为底层数据结构的,hash_set是以哈希表(Hash table)作为底层数据结构的.set可以在时间复杂度为O(l ...
- C++ STL中的常用容器浅谈
STL是C/C++开发中一个非常重要的模板,而其中定义的各种容器也是非常方便我们大家使用.下面,我们就浅谈某些常用的容器.这里我们不涉及容器的基本操作之类,只是要讨论一下各个容器其各自的特点.STL中 ...
- STL中deque
以下学习一下STL中另一种序列容器——deque. deque表示double-ended queue,即双向队列,deque是通过作为动态数组的方式实现的,这样可以在两端插入元素.因此,deque可 ...
- STL中list用法
本文以List容器为例子,介绍了STL的基本内容,从容器到迭代器,再到普通函数,而且例子丰富,通俗易懂.不失为STL的入门文章,新手不容错过! 0 前言 1 定义一个list 2 使用list的成员函 ...
随机推荐
- 在centos7.6上部署前后端分离项目Nginx反向代理vue.js2.6+Tornado5.1.1,使用supervisor统一管理服务
原文转载自「刘悦的技术博客」https://v3u.cn/a_id_102 这一次使用vue.js+tornado的组合来部署前后端分离的web项目,vue.js不用说了,前端当红炸子鸡,泛用性非常广 ...
- 【原创】Selenium获取请求头、响应头
本文仅供学习交流使用,如侵立删! Selenium获取请求头.响应头 操作环境 win10 . mac Python3.9 selenium.seleniumwire selenium是没有办法直接获 ...
- GDB技巧:使用终端界面模式
欢迎来到 GreatSQL社区分享的MySQL技术文章,如有疑问或想学习的内容,可以在下方评论区留言,看到后会进行解答 GreatSQL社区原创内容未经授权不得随意使用,转载请联系小编并注明来源. 简 ...
- 活动报名|对话贡献者:DolphinScheduler x Pulsar 在线 Meetup
各位 DolphinScheduler 和 Pulsar 社区的小伙伴们,Apache DolphinScheduler x Pulsar 在线 Meetup 来啦! 导语 大数据任务调度.消息流的订 ...
- ASP.NET Core依赖注入系统学习教程:容器对构造函数选择的策略
.NET Core的依赖注入容器之所以能够为应用程序提供服务实例,这都归功于ServiceDescriptor对象提供的服务注册信息.另外,在ServiceDescriptor对象中,还为容器准备了3 ...
- Slf4j的MDC初尝试
为什么会用到MDC? 本人使用Java两年时间,鉴于经验有限,在开发java后端代码过程中,为了定位问题,希望同一个线程的requestId可以从web层的日志一直输出到dao层,这样使用Linux命 ...
- RabbitMQ协议-AMQP 0-9-1 (高级消息队列协议)
工作模型 producer:生产者 Connection:TCP长连接,AMQP 0-9-1 连接通常是长期存在的.AMQP 0-9-1 是一个应用层协议,它使用 TCP 进行可靠传输.连接使用身份验 ...
- HTML短链接
短链接跳转方法 新建一个目录名称就是短链接字符列如:1 创建一个index.html文件里面添加代码如下 <script type="text/javascript"> ...
- OpenJudge 1.5.15 银行利息
15:银行利息 总时间限制: 1000ms 内存限制: 65536kB 描述 农夫约翰在去年赚了一大笔钱!他想要把这些钱用于投资,并对自己能得到多少收益感到好奇.已知投资的复合年利率为R(0到20之间 ...
- Kingbase V8R6集群安装部署案例---脚本在线一键缩容
案例说明: KingbaseES V8R6支持图形化方式在线缩容,但是在一些生产环境,在服务器不支持图形化界面的情况下 ,只能通过脚本命令行的方式执行集群的部署或在线缩容. Tips: Kingb ...