【C++】优先级队列仿函数

一.priority_queue的使用

二.仿函数

三、priority_queue的模拟实现

首先，我们先来了解一下什么是优先级队列

priority_queue，翻译为优先级队列，是一种容器适配器

底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。
它支持以下操作：

empty()：检测容器是否为空
size()：返回容器中有效元素个数
front()：返回容器中第一个元素的引用
push_back()：在容器尾部插入元素
pop_back()：删除容器尾部元素
默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。
需要支持随机访问迭代器，以便始终在内部保持堆结构

一.priority_queue的使用

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue 所以它和队列是两种不同的结构。队列满足的是先进先出，而优先级队列则是优先级高的先出
注意：默认情况下priority_queue是大堆

在传的参数中，除了class T之外，还有一个class Container 和class Compare

Container（用于存放数据的类模板）:优先级队列默认使用vector作为其底层存储数据的容器，支持[ ]的使用，支持随机访问

Compare（用于自定义比较操作的方法）：仿函数为less，表示默认情况下priority_queue是大堆（反之，我们如果在这里传的是greater则建小堆）

这是priority_queue常用的一些接口：

函数声明	接口说明
priority_queue()/priority_queue(first, last)	构造一个空的优先级队列
empty( )	检测优先级队列是否为空，是返回true，否则返回 false
top( )	返回优先级队列中最大(最小元素)，即堆顶元素
push(x)	在优先级队列中插入元素x
pop()	删除优先级队列中最大(最小)元素，即堆顶元素

说了这么多，下面我们就来上手实操一下吧~

这里的priority_queue<>里面只传了一个int，剩下的则用缺省值，第二个默认传默认使用vector

第三个more是less

想让priority_queue是小堆，我们需要自己传参greater，也就要将初始化的三个参数补全~

然后是迭代器区间构造

在使用的最后部分，我们来看一下priority_queue在OJ中的使用吧~
215.数组中的第K个最大元素

. - 力扣（LeetCode）

参考代码：

class Solution 
{
public:int findKthLargest(vector<int>& nums, int k) {// 将数组中的元素先放入优先级队列中priority_queue<int> p(nums.begin(), nums.end());// 将优先级队列中前k-1个元素删除掉for(int i= 0; i < k-1; ++i){p.pop();}return p.top();}
};

OK,讲完了使用，下面我们来看一下什么是仿函数

二.仿函数

首先，Q：仿函数是函数吗？

A：不是，仿函数是类，是一个类对象，仿函数要重载operator()，其类的对象可以像函数一样使用。

下面我们直接自己来通过代码来看一看仿函数：

在C语言中，我们通过传入函数指针解决比较的问题，但函数指针是非常规的定义，使用起来其实并不舒服

所以虽然C++兼容了C，但是C++并没有继续利用函数指针，而是通过仿函数来控制

之前在类和对象中篇的博客中，曾经写过日期类的实现，比较大小需要我们自己去重载>以及<

然后如果需求改变我们需要手动更改>,<的比较符号

而现在我们学习了仿函数，要比较的日期的大小，我们可以通过自己定义仿函数的方式来实现我们的需求:

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){_cout << d._year << "-" << d._month << "-" << d._day;return _cout;}
private:int _year;int _month;int _day;
};void TestPriorityQueue()
{//小堆priority_queue <Date, vector<Date>, greater<Date>> q1;q1.push(Date(2024, 6, 29));q1.push(Date(2024, 6, 28));q1.push(Date(2024, 6, 30));while (!q1.empty()){cout << q1.top() << " ";q1.pop();}cout << endl;
}int main()
{TestPriorityQueue();return 0;}

最后，我们来对优先级队列priority_queue的模拟实现！

三、priority_queue的模拟实现

重要的接口：

push与向上调整：

因为优先级队列就是堆，所以插入一个数之后，我们还需要去进行向上调整

void adjust_up(size_t child)
{//仿函数Compare com;size_t parent = (child - 1) / 2;while (child > 0){//if ( _con[parent]<_con[child])if (com(_con[parent], _con[child])){swap(_con[child], _con[parent]);child = parent;//更新孩子parent = (child - 1) / 2;//更新双亲}else{break;}}
}void push(const T& x)
{_con.push_back(x);adjust_up(_con.size() - 1);
}

pop与向下调整

删除一个数之后，我们还需要去进行向下调整

void adjust_down(size_t parent)
{Compare com;//仿函数size_t child = parent * 2 + 1;while (child < _con.size()){//if (child + 1 < _con.size() && _con[child] < _con[child + 1])if (child + 1 < _con.size() && com(_con[child], _con[child + 1])){child++;}//if (_con[parent]<_con[child])if (com(_con[parent], _con[child])){swap(_con[child], _con[parent]);parent = child;child = parent * 2 + 1;}else{break;}}
}void pop()
{swap(_con[0], _con[_con.size() - 1]);//交换堆顶和最后一个元素_con.pop_back();//尾删adjust_down(0);//向下调整
}

迭代器区间构造

首先，将数据push_back进这个堆，然后，数据进去之后我们还要建堆，利用向下调整算法：从倒数第一个非叶子节点（下标为（size() - 1 - 1）/2）开始进行向下调整

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);//向下调整}
}

priority_queue.h 整体代码：

#include<vector>namespace wyh
{//仿函数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 = vector<T>, class Compare = less<T>>class priority_queue{public:priority_queue()//构造{}//迭代器区间构造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 adjust_up(size_t child)//向上调整{size_t parent = (child - 1) / 2;while (child > 0){//if ( _con[parent]<_con[child])if (comp(_con[parent], _con[child])){swap(_con[child], _con[parent]);child = parent;parent = (child - 1) / 2;}else{break;}}}void push(const T& x){_con.push_back(x);adjust_up(_con.size() - 1);}void adjust_down(size_t parent)//向下调整{size_t child = parent * 2 + 1;while (child < _con.size()){if (child + 1 < _con.size() && comp(_con[child], _con[child + 1])){child++;}if (comp(_con[parent], _con[child])){swap(_con[child], _con[parent]);parent = child;child = parent * 2 + 1;}else{break;}}}void pop(){swap(_con[0], _con[_con.size() - 1]);_con.pop_back();adjust_down(0);}bool empty() const{return _con.empty();}const T& top() const{return _con[0];}private:Container _con;Compare comp;};
}

test.cpp 测试代码：