STL——优先队列

基本定义

STL中定义优先队列的模板类为priority_queue，其定义如下：
template , class Compare = less > class priority_queue;
模板里面有三个参数，第一个为元素的类型，第二个为所使用的容器（vector或deque），第三个

为一个比较的规则，决定是最大优先队列还是最小优先队列，默认的less为最大优先队列，实现方

式是最大堆，greater为最小优先队列，实现方式是最小堆，结构都是二叉树。                                       
priority_queue支持的方法和一般队列支持的方法大体相同。

使用方法

使用模板类priority_queue时要加上头文件，下面给出针对不同数据类型的使用方法。

基本数据类型

对于 int ，string 等常规数据类型的声明如下。

最大优先队列：priority_queue MaxHeap;

                  或：priority_queue, less > MaxHeap

最小优先队列：priority_queue，greater > MinHeap;

int main()
{
    priority_queue, less > MaxHeap;
    MaxHeap.push(1);
    MaxHeap.push(2);
    MaxHeap.push(3);
    MaxHeap.push(4);
    while(!MaxHeap.empty())
    {
        int vall=MaxHeap.top();
        cout<, greater > MinHeap;
    MinHeap.push(1);
    MinHeap.push(2);
    MinHeap.push(3);
    MinHeap.push(4);
    while(!MinHeap.empty())
    {
        int val=MinHeap.top();
        cout<

上述代码输出结果是 ：

4，3，2，1。为最大优先队列。

1，2，3，4。为最小优先队列。

复合数据类型

对于结构体和类等数据类型的声明

例如：定义一个point类，类里定义了两个数据成员（X，Y）。

class point{
public:
 double X;
 double Y;
};

使用模板类priority_queue对point类的优先队列声明的模板是：

priority_queue,  ???> MaxHeap/MinHeap

但是缺少用于比较的类型，假设我们想让X来决定其优先级，这时我们有两种方法来自定义我

们的比较函数。

一、在point类中重载 < 运算符。

第一、在类内定义多参数的双目运算符，代码如下：

class point{
public:
 double X;
 double Y;
bool operator < ( const point &a, const point &b )
{
    return a.X < b.X;
}
};

上述代码会显示如下错误：

错误原因是：

1.你为point类定义operator<作为成员函数，所以它有一个隐式的point*参数this指针
2. 一个双目运算符重载应该在类定义之外。 class point { ... }; bool operator<(const point& a, const point & b) { return a.X < b.X; }

所以双目运算符的重载应该在类外进行。

class point{
public:
 double X;
 double Y;
};

bool operator < ( const point &a, const point &b )//返回较小的数
{
    return a.X < b.X;
}

bool operator < ( const point &a, const point &b )//返回较大的数
{
    return a.X > b.X;
}

bool operator > ( const point &a, const point &b )//返回较大的数
{
    return a.X > b.X;
}

bool operator > ( const point &a, const point &b )//返回较小的数
{
    return a.X < b.X;
}

第二、在类内定义单参数的多目运算符，代码如下：

class point{
public:
 double X;
 double Y;
bool operator > ( const point &a)const//返回较小的数
{
    return a.X > this->X;
}

bool operator > ( const point &a)//返回较大的数
{
    return a.X < this->X;
}

bool operator < ( const point &a)//返回较大的数
{
    return a.X < this->X;
}

bool operator < ( const point &a)//返回较小的数
{
    return a.X > this->X;
}

};

此时，在类内定义单参数的多目运算符时对优先队列的声明如下：

class point{
public:
 double X;
 double Y;


bool operator < ( const point &a)const//返回较大的数
{
    return a.X < this->X;
}

};

上述代码完成最大优先队列的声明：priority_queue MaxHeap

class point{
public:
 double X;
 double Y;

bool operator < ( const point &a)const//返回较小的数
{
    return a.X > this->X;
}

};

上述代码完成最小优先队列的声明：priority_queue MinHeap

二、在类外自定义比较函数

//定义最大优先队列的比较函数
struct LessThanByX
{
  bool operator()(const point& a, const point& b) const
  {
    return a.X > b.X;
  }
};
//定义最小优先队列的比较函数
struct GreaterThanByX
{
  bool operator()(const point& a, const point& b) const
  {
    return a.X < b.X;
  }
};

最大优先队列的声明：priority_queue,  LessThanByX> MaxHeap

最小优先队列的声明：priority_queue,  GreaterThanByX> MinHeap

索引数据类型

例如在求最短路径的Dijkstra算法中，我们希望在优先队列中存储的是顶点的索引v，每次从优先队列中需要取出的是源点s到各个顶点的最短距离disTo[v]，所以决定其优先级的是距离，这时候我们就可以使用索引优先队列。
我们还是要自定义比较类型，代码如下：

//索引优先队列,存储的是顶点索引v,比较的是disTo[v]
struct cmp
{
    bool operator ()(int v1, int v2)
    {
        return distTo[v1] > distTo[v2];   //小值优先
    }
};

声明：priority_queue,  cmp> MaxHeap/MinHeap