学习：STL----优先队列

优先队列是队列的高级版，最大的特点是可以内部实现排序

优先队列的定义

---

优先队列内部使用堆排序，从而实现队列内一直保持着某种顺序规律（比如递增，递减等）

在使用优先队列时，首先要引入头文件：#include <queue>

定义一个新类型的优先队列，通常使用：

priority_queue<[type]> [name]

type为优先队列内所存元素的数据类型，name为你定义的优先队列的名字，那么优先队列内部就会按照type类型数据从大到小排列，队列第一个元素为最大的元素。

当然，你也可以让优先队列内元素按照你想要的顺序进行排列，之后说明。

---

优先队列的操作

---

对一个优先队列，具有许多种操作，每次操作就使用[name].[操作函数]的方式进行。

优先队列有以下操作函数：　　　　　　　　　　　　　　　

empty()	返回值为bool类型，判断优先队列是否为空，为空返回true，否则返回false；
emplace(type1　x1,...,type　xn)	这个有点复杂，后面说；
pop()	返回值为void类型，删除队列第一个元素；
push(type x)	返回值为void类型，向队列末尾插入一个元素，参数x的数据类型type必须和此优先队列所存数据的数据类型相同；
size()	返回值一般为一个数，表示队列中当前所存元素的多少；
swap(priority_queue<type> x)	返回值为void类型，交换两个队列内的元素；
top()	返回值为type类型，返回队列第一个元素的值。

其中emplace(type1  x₁,.......,typen  x_n)函数参数数量和类型是不确定的，只有当优先队列内部存的是结构体或者类，这个函数才有它独特的作用

emplace的参数会传到构造函数中构造一个新的对象，然后再把对象放到优先队列里，和push类似，但是push的参数只有一个，且参数数据类型必须和优先队列所存数据类型相同

 

例如，先创建一个结构体和优先队列：

struct op{
    int a;
    int b;
    int c;
    op(int a1,int b1,int c1){
        this->a=a1;
        this->b=b1;
        this->c=c1; 
    }
    bool operator<(const op &x)const{
        return this->a<x.a;
    }
};
priority_queue<op> que;

那么，由于结构体op的构造函数需要三个参数，所以函数emplace就应该有三个参数，例如：

que.emplace(1,2,3);

这条语句相当于

op a(1,2,3);
que.push(a);

或者

que.push(op(1,2,3));

注意：编译器要支持c++11才能使用emplace函数。

---

自定义优先队列顺序

---

基本数据类型排序

在定义一个新的优先队列时

priority_queue<int> que1;

优先队列内部默认按照int类型数据由大到小排序。

还有一种由大到小的定义方式：

priority_queue<int,vector<int>,less<int> > que1;

注意：末尾的两个">"符号之间要有空格，不然会被当做">>"运算符，从而报错

如果想要队列内部按照double类型由小到大排序，只有一种定义方式：

priority_queue<double,vector<double>,greater<double> > que1;

结构体&类的排序

方法1：定义一个结构体或者类同时，还要重载一下运算符"<"，只用重载"<"，不要重载"="和">"（这里需要一点点c++的知识），例如：

struct op{
    int a;
    int b;
    int c;
    op(int a1,int b1,int c1){
        this->a=a1;
        this->b=b1;
        this->c=c1; 
    }
    bool operator<(const op &x)const{
        return this->a>x.a;
    }
};

记住红色部分的两个const不要忽略。

然后定义优先队列

priority_queue<op> que;

那么此优先队列中的对象，会按照成员a的值由小到大排序（此时以成员a的值为主键）

如果想要按成员b的值由大到小排序，那么重载函数应该为：

bool operator<(const op &x)const{
     return this->b<x.b;
}

注意大于号和小于号的使用

方法2：重新定义一个结构体，重载"()"运算符，例如：

struct op{
    int a;
    int b;
    int c;
    op(int a1,int b1,int c1){
        this->a=a1;
        this->b=b1;
        this->c=c1; 
    }
};
struct comp{
    bool operator()(const op &p1,const op &p2){
        return p1.a<p2.a;
    }
};

然后定义优先队列

priority_queue<op,vector<op>,comp> que;

于是此优先队列里的对象也会按照成员a的值由大到小排序。

当然，如果换成">"

struct comp{
    bool operator()(const op &p1,const op &p2){
        return p1.a>p2.a;
    }
};

对象就会按照a的值从小到大排序

---