目录

1、priority_queue的使用

2、实现没有仿函数的优先级队列

3、实现有仿函数的优先级队列

3.1 仿函数

3.2 真正的优先级队列

3.3 优先级队列放自定义类型

1、priority_queue的使用

priority_queue是优先级队列，是一个容器适配器，不满足先进先出的特点，而是优先级高的先出，默认的适配器是vector，底层是一个堆，默认是大堆

priority_queue是可以进行迭代器区间初始化的

void test_priority_queue1()
{vector<int> v = { 3,2,7,6,0,4,1,9,8,5 };priority_queue<int> q1;for (auto& e : v)q1.push(e);while (!q1.empty()){cout << q1.top() << " ";q1.pop();}cout << endl;
}

void test_priority_queue2()
{vector<int> v = { 3,2,7,6,0,4,1,9,8,5 };priority_queue<int> q1(v.begin(), v.end());while (!q1.empty()){cout << q1.top() << " ";q1.pop();}cout << endl;
}

可以用数组直接初始化 

void test_priority_queue3()
{int v[10] = {3,2,7,6,0,4,1,9,8,5};priority_queue<int> q1(v, v + 10);while (!q1.empty()){cout << q1.top() << " ";q1.pop();}cout << endl;
}

上面3段代码的结果都是相同的，都是9 8 7 6 5 4 3 2 1 0，因为默认是建大堆

2、实现没有仿函数的优先级队列

namespace cxf
{template<class T,class Container = std::vector<T>>class priority_queue{public:// 建大堆void adjust_up(int child){int parent = (child - 1) / 2;while (child > 0){if (_con[parent] < _con[child]){std::swap(_con[parent], _con[child]);child = parent;parent = (child - 1) / 2;}else break;}}void adjust_down(int parent){int child = parent * 2 + 1;while (child < _con.size()){if (child + 1 < _con.size() && _con[child] < _con[child + 1]){++child;}if (_con[parent] < _con[child]){std::swap(_con[parent], _con[child]);parent = child;child = parent * 2 + 1;}else break;}}// 强制编译器生成默认的构造函数，因为下面有迭代器区间初始化，这样没办法用默认构造函数priority_queue() = default;// 迭代器区间初始化template<class InputIterator>priority_queue(InputIterator first, InputIterator last){while (first != last){_con.push_back(*first);++first;}// 建堆for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--){adjust_down(i);}}void push(const T& x){_con.push_back(x);adjust_up(_con.size() - 1);}void pop(){std::swap(_con[0], _con[_con.size() - 1]);_con.pop_back();adjust_down(0);}const T& top(){return _con[0];}size_t size(){return _con.size();}bool empty(){return _con.empty();}private:Container _con;};
}

上面是建大堆的优先级队列，当要建小堆时，需要在adjust_up和adjust_up中将<改成>，这样是十分麻烦的，为例能够在不修改代码的情况下完成建小堆，所以引入了仿函数的概念

3、实现有仿函数的优先级队列

3.1 仿函数

仿函数就是重载了operatror()的类，类的对象可以像调用函数一样使用

operator()的特点是参数个数和返回值个数可以根据需求来定，很灵活，所以有很多用法

若用class来定义仿函数的类要加public，所以通常会用struct来定义仿函数

根据仿函数就可以来实现一个既可建大堆，又可建小堆的优先级队列

3.2 真正的优先级队列

namespace cxf
{template<class T>class myless // 小于是大堆{public:bool operator()(const T& x, const T& y){return x < y;}};template<class T>class mygreater // 大于是小堆{public:bool operator()(const T& x, const T& y){return x > y;}};template<class T, class Container = std::vector<T>, class Comapre = myless<T>>class priority_queue{public:void adjust_up(int child){Comapre comfunc;int parent = (child - 1) / 2;while (child > 0){//if (_con[parent] < _con[child])if(comfunc(_con[parent],_con[child])){std::swap(_con[parent], _con[child]);child = parent;parent = (child - 1) / 2;}else break;}}void adjust_down(int parent){Comapre comfunc;int child = parent * 2 + 1;while (child < _con.size()){/*if (child + 1 < _con.size() && _con[child] < _con[child + 1])*/if (child + 1 < _con.size() && comfunc(_con[child], _con[child + 1])){++child;}//if (_con[parent] < _con[child])if(comfunc(_con[parent],_con[child])){std::swap(_con[parent], _con[child]);parent = child;child = parent * 2 + 1;}else break;}}// 强制编译器生成默认的构造函数，因为下面有迭代器区间初始化，这样没办法用默认构造函数priority_queue() = default;// 迭代器区间初始化template<class InputIterator>priority_queue(InputIterator first, InputIterator last){while (first != last){_con.push_back(*first);++first;}// 建堆for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--){adjust_down(i);}}void push(const T& x){_con.push_back(x);adjust_up(_con.size() - 1);}void pop(){std::swap(_con[0], _con[_con.size() - 1]);_con.pop_back();adjust_down(0);}const T& top(){return _con[0];}size_t size(){return _con.size();}bool empty(){return _con.empty();}private:Container _con;};
}

priority_queue的第三个模板参数就是仿函数 

在STL库中的priority_queue来建小堆

3.3 优先级队列放自定义类型

class Date
{
public:Date(int year = 1900, int month = 1, int day = 1): _year(year), _month(month), _day(day){}bool operator<(const Date& d)const{return (_year < d._year) ||(_year == d._year && _month < d._month) ||(_year == d._year && _month == d._month && _day < d._day);}bool operator>(const Date& d)const{return (_year > d._year) ||(_year == d._year && _month > d._month) ||(_year == d._year && _month == d._month && _day > d._day);}friend ostream& operator<<(ostream& _cout, const Date& d);
private:int _year;int _month;int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{_cout << d._year << "-" << d._month << "-" << d._day;return _cout;
}
int main()
{priority_queue<Date> q1;q1.push(Date(2022, 9, 9));q1.push(Date(2022, 9, 10));q1.push(Date(2022, 9, 11));while (!q1.empty()){cout << q1.top() << endl;q1.pop();}return 0;
}

结果是正确的，因为只要这个自定义类型是能够比较大小的，都能使用优先级队列

但是若比较的不是这个自定义类型，而是这个自定义类型的指针，则会出现随机结果

int main()
{priority_queue<Date*> q1;q1.push(new Date(2022, 9, 9));q1.push(new Date(2022, 9, 10));q1.push(new Date(2022, 9, 11));while (!q1.empty()){cout << *q1.top() << endl;q1.pop();}return 0;
}

此时是错误的，并且每次运行程序结果也不一定都相同。因为less比较的是Date*，是根据地址比较的，而new出来的地址是随机的，所以几次的运行结果也会不同。而且这个比较从逻辑上就是错误的，因为不应该使用对象的地址去比较，应该使用对象的值去比较

所以可以自己写一个仿函数，达到想要的目的

struct PDateLess
{bool operator()(Date* p1, Date* p2){return *p1 < *p2;}
};
int main()
{priority_queue<Date*, vector<Date*>, PDateLess> q1;q1.push(new Date(2022, 9, 9));q1.push(new Date(2022, 9, 10));q1.push(new Date(2022, 9, 11));while (!q1.empty()){cout << *q1.top() << endl;q1.pop();}return 0;
}

此时就正确的

所以仿函数不仅可以支持比较大小，还可以支持修改比较逻辑，如果默认的比较逻辑不是想要的或者不支持比较大小，都可以通过仿函数来控制。