队列

最新推荐文章于 2022-06-01 17:44:22 发布

蝶恋忆梦

最新推荐文章于 2022-06-01 17:44:22 发布

阅读量190

点赞数

队列（Queue）与栈一样，是一种线性存储结构，它具有如下特点：

1.队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FIFO结构。
2.在队尾添加元素，在队头删除元素。

队列的相关概念
1.队头与队尾：允许元素插入的一端称为队尾，允许元素删除的一端称为队头。
2.入队：队列的插入操作。
3.出队：队列的删除操作。

C++队列queue模板类的定义在头文件中,queue 模板类需要两个模板参数，一个是元素类型，一个容器类型，元素类型是必要的，容器类型是可选的，默认为deque 类型。

C++队列Queue类成员函数有:

1.back() 返回最后一个元素

2.empty() 如果队列空则返回真

3.front() 返回第一个元素

4.pop() 删除第一个元素

5.push() 在末尾加入一个元素

6.size() 返回队列中元素的个数

例如0-5，共6个元素，我们对其进行入队出队操作：
代码例：

#include<queue>
#include<cstdio>
using namespace std;
int main()
{
      queue <int> q;
      printf("现在队列中元素个数%d\n\n",q.size());
      for(int i =0; i<5 ; i++)
      {
            q.push(i);//入队
      }
      for(int i=0; !q.empty(); i++)
      {
            printf("队列剩余元素个数为:%d\n\n"q.size());
            printf("队列的第一个元素为:%d   队列最后一个元素为:%d\n\n",q.front(),q.back());
            q.pop();//出队
       }
       q.push(8);//在队列的最后一位添加一个元素
       printf("队列压入的元素为：%d\n",q.back());
       return 0;
    }

输出结果为
在这里插入图片描述
例如我们有一个存储整型元素的队列，我们依次入队：{1，2，3}

添加元素时，元素只能从队尾一端进入队列，也即是2只能跟在1后面，3只能跟在2后面。
如果队列中的元素要出队：

元素只能从队首出队列，出队列的顺序为：1、2、3，与入队时的顺序一致，这就是所谓的“先进先出”。

1.3 队列的操作

队列通常提供的操作：
1.入队：通常命名为push()
2.出队：通常命名为pop()
3.求队列中元素个数
4.判断队列是否为空
5.获取队首元素

优先队列

成员函数有：
1.empty() 如果优先队列为空，则返回真
2.pop() 删除第一个元素
3.push() 加入一个元素
4.size() 返回优先队列中拥有的元素的个数
5.top() 返回优先队列中有最高优先级的元素
例代码：

#include<cstdio>
#include<queue>
using namespace std;
int main()
{
    	priority_queue<int>Q;
    	for(int i=1;i<=5;i++)
    	{
        	int x;
        	scanf("%d",&x);//压入输入的元素
        	Q.push(x);
    	}
    	for(int i=1;i<=5;i++)
    	{
       		printf("优先队列中最大元素为:%d\n\n",Q.top());//由于没有定义优先级，优先队列将按照元素大小来确定优先级
       		Q.pop();
   		}
    	return 0;
}

我们输入乱序的一堆数，在输出的时候我们可以看到，这些数是按照谁最大谁先输出
在这里插入图片描述
现在对优先队列进行自定义安排优先级，这里我们自定义了两个队列，它们的优先级相反

代码：

#include<cstdio>
#include<queue>
#include<algorithm>
using namespace std;
struct node
{
	    int time;
    	friend bool operator < (node n1, node n2)
    	{
        	return n1.time<n2.time;//自定义优先级从大到小
   		 }
} a;
struct node1
{
    	int time;
    	friend bool operator <(node1 n1,node1 n2)
    	{
        		return n1.time>n2.time;//从小到大
  		 }
} b;
int main()
{
    	priority_queue<node>Q;
    	priority_queue<node1>Q1;
    	int i;
    	for(i=0; i<5; i++)
   		{
        		int x;
        		scanf("%d",&x);
        		a.time=x;
       			b.time=x;
        		Q.push(a);
        		Q1.push(b);
   		 }
    	printf("队列1中优先级输出顺序为:\n");
    	while(!Q.empty())
   		{
        		a=Q.top();
        		Q.pop();
        		printf("%d ",a);
    	}
    	printf("\n");
    	printf("队列2中优先级输出顺序为:\n");
    	while(!Q1.empty())
    	{
        		b=Q1.top();
        		Q1.pop();
        		printf("%d ",b);
    	}
    return 0;
}

运行结果
在这里插入图片描述

less和greater优先队列

还是以int为例，先来声明：
1.priority_queue <int,vector,less > p;
2.priority_queue <int,vector,greater > q;

再次强调：“>”不要两个拼在一起。

#include<cstdio>
#include<queue>
using namespace std;
priority_queue <int,vector<int>,less<int> > p;
priority_queue <int,vector<int>,greater<int> > q;
int a[5]={10,12,14,6,8};
int main()
{
		for(int i=0;i<5;i++)
				p.push(a[i]),q.push(a[i]);
		printf("less<int>:")；
		while(!p.empty())
				printf("%d ",p.top()),p.pop();	
		printf("\ngreater<int>:")；
		while(!q.empty())
				printf("%d ",q.top()),q.pop();
}

运行结果:
less<int>:14 12 10 8 6 greater<int>:6 8 10 12 14

所以，我们可以知道，less是从大到小，greater是从小到大。
首先是优先队列的各种声明方法。

#include
using namespace std;
要加上这两个头文件。
最完整的声明公式（吧）形如：
**priority_queue< 结构名, vector<结构名> , greater/less<结构名> > 队列名;**
可以简写为priority_queue<结构名>,不过这样只能从大到小了。
三个结构名请保持一致，如int,double,long long，包括结构体（struct等）。

作者：lee371042
来源：CSDN
原文：https://blog.csdn.net/lee371042/article/details/81135007