原始声明
template <class T, class Container = vector<T>,
class Compare = less<typename Container::value_type> > class priority_queue;
prority_queue默认按降序排列,即队首元素为值最大的。
函数速览
#include <queue> //头文件
prority_queue<type> team; //创建指定类型的优先队列,可以是模板类型
team.empty() //若队列为空返回true
team.size() //返回队列内元素个数(int)
team.top() //返回队首元素(优先级最大的)
team.push(element) //插入元素,
team.pop()
team.emplace(value) //构造元素插入队列
team.swap(other_team) //与另一个优先队列交换全部元素以及排序方式
pair的优先队列
以first为第一关键字,second为第二关键字排序
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main()
{
priority_queue<pair<int, int> > a;
pair<int, int> b(1, 2);
pair<int, int> c(1, 3);
pair<int, int> d(2, 5);
a.push(d);
a.push(c);
a.push(b);
while (!a.empty())
{
cout << a.top().first << ' ' << a.top().second << endl;
a.pop();
}
}
输出:
2 5
1 3
1 2
priority_queue::emplace
Adds a new element to the priority_queue. This new element is
constructed in place passing args as the arguments for its
constructor.
// priority_queue::emplace
#include <iostream> // std::cout
#include <queue> // std::priority_queue
#include <string> // std::string
int main ()
{
std::priority_queue<std::string> mypq;
mypq.emplace("orange");
mypq.emplace("strawberry");
mypq.emplace("apple");
mypq.emplace("pear");
std::cout << "mypq contains:";
while (!mypq.empty())
{
std::cout << ' ' << mypq.top();
mypq.pop();
}
std::cout << '\n';
return 0;
}
Output:
mypq contains: strawberry pear orange apple
priority_queue::swap
// priority_queue::swap
#include <iostream> // std::cout
#include <queue> // std::priority_queue
int main ()
{
std::priority_queue<int> foo,bar;
foo.push (15); foo.push(30); foo.push(10);
bar.push (101); bar.push(202);
foo.swap(bar);
std::cout << "size of foo: " << foo.size() << '\n';
std::cout << "size of bar: " << bar.size() << '\n';
return 0;
}
Output:
size of foo: 2
size of bar: 3
自定义排序函数
其中bool operator > (Type a,Type b)
是 运算符重载,重载>
表示升序排列,队首元素key最小,重载<
表示降序排序,队首元素key最大
struct BinaryNode
{
int w;
int id;
int left;
int right;
};
bool operator > (Node a, Node b)
{
return a.w > b.w;
}
定义之后,通过以下语句创建一个优先队列F
priority_queue<Node, vector<Node>, greater<Node> > F;
下面是一个简单示例:
struct st
{
int num;
};
bool operator > (st a,st b)
{
return a.num > b.num;
}
int main()
{
priority_queue<st, vector<st>, greater<st>> q;
q.push({ 2 });
q.push({ 1 });
q.push({ 3 });
cout << q.top().num << endl;
}
Output:
1
模板类型也可以:
template<typename T>
struct Node
{
T data;
int w;
};
//---------------------------------------------------------------------------
template<typename T>
bool operator > (Node<T> a, Node<T> b)
{
return a.w > b.w;
}
之后声明语句如下:
priority_queue<Node<char>, vector<Node<char>>, greater<Node<char>> > F;