优先队列 priority_queue

1. 优先队列是一种功能强大的队列，它可以自动排序。

2. 头文件：#include<queue>

3. 声明的基本格式：priority_queue<结构类型> 队列名;
   如：

       priority_queue <node> q;
       //node是一个结构体，结构体里重载了‘<’小于符号
       priority_queue <int,vector<int>,greater/less<int> > q;   
       //不需要#include<vector>头文件
       //注意后面两个“>”不要写在一起，“>>”是右移运算符
       //greater从小到大
       //less从大到小
   

4. 基本操作：

   priority_queue <node> q;
   
   q.size();//返回q里元素个数
   q.empty();//返回q是否为空，空则返回1，否则返回0
   q.push(k);//在q的末尾插入k
   q.pop();//删掉q的第一个元素
   q.top();//返回q的第一个元素
   

5. 默认的优先队列（非结构体结构）

   #include<cstdio>
   #include<queue>
   using namespace std;
   priority_queue <int> q;
   int main()
   {
   	q.push(10),q.push(8),q.push(12),q.push(14),q.push(6);
   	while(!q.empty())
   		printf("%d ",q.top()),q.pop();
   }
   
   在这个优先队列里依次插入10、8、12、14、6，再输出
   结果：14 12 10 8 6
   按从大到小排序的！
   

6. 默认的优先队列（结构体，重载小于）

   #include<cstdio>
   #include<queue>
   using namespace std;
   struct node       //node结构体有两个成员，x和y，它的小于规则是x小者小
   {
   	int x,y;
   	bool operator < (const node & a) const
   	{
   		return x<a.x;
   	}
   }k;
   priority_queue <node> q;
   int main()
   {
   	k.x=10,k.y=100; q.push(k);
   	k.x=12,k.y=60; q.push(k);
   	k.x=14,k.y=40; q.push(k);
   	k.x=6,k.y=80; q.push(k);
   	k.x=8,k.y=20; q.push(k);
   	while(!q.empty())
   	{
   		node m=q.top(); q.pop();
   		printf("(%d,%d) ",m.x,m.y);
   	}
   }
   
   插入(10,100),(12,60),(14,40),(6,20),(8,20)这五个node
   结果：(14,40) (12,60) (10,100) (8,20) (6,80)
   按照重载后的小于规则，从大到小排序的。
   

7. less和greater优先队列

   #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是从小到大。
   

8. 完整的声明公式：priority_queue< 结构名, vector<结构名> , greater/less<结构名> > 队列名;可以简写为priority_queue<结构名>,不过这样只能从大到小了
   三个结构名请保持一致，如int,double,long long，包括结构体（struct等）。

   系统自带的数据结构的小于规则是显然的，对于结构体，需要通过重载运算符等方式规定，如：

   struct point
   {
   	int x,y;
   	bool operator < (const point &p) const
   	{
   		return x*x+y*y<p.x*p.x+p.y*p.y;
   		//假设这是平面上的两个点，规定两个点的大小关系为距离原点的距离小者小。
   		//这个函数的意思是，当你使用小于运算符判断一个点（假设是a）与另一个点
   		//（函数里的p）的大小关系时，系统会判断a.x*a.x+a.y*a.y是否<p.x*p.x+p.y*p.y
   		//如果上述式子成立，就说明a点是小于p点的 ( return 1 ; ->小于运算符得出的结果为真)
   	}
   };
   priority_queue<point> QP;
   
   

9. 代码：

   #include <iostream>
   #include <queue>
   
   using namespace std;
   
   priority_queue<int> que1;   //声明一个int类型的优先队列
   priority_queue<int, vector<int>, less<int> > que2;   //从大到小//注意>>不能相连，因为“>>”是右移运算符
   priority_queue<int, vector<int>, greater<int> > que3;     //从小到大
   
   int main()
   {
   	int a[5] = { 30,41,42,15,54 };
   	for (int i = 0; i < 5; i++)
   	{
   		que1.push(a[i]);
   		que2.push(a[i]);
   		que3.push(a[i]);
   	}
   	cout << "默认优先队列" << endl;
   	for (int i = 0; i < 5; i++)
   	{
   		int k = que1.top();
   		que1.pop();
   		cout << k << " ";
   	}
   	cout << "\nLess优先队列" << endl;
   	for (int i = 0; i < 5; i++)
   	{
   		int k = que2.top();
   		que2.pop();
   		cout << k << " ";
   	}
   	cout << "\ngreater优先队列" << endl;
   	for (int i = 0; i < 5; i++)
   	{
   		int k = que3.top();
   		que3.pop();
   		cout << k << " ";
   	}
   	cout << endl;
   
   	system("pause");
   	return 0;
   }
   
   

   

参考：https://blog.csdn.net/c20182030/article/details/70757660