目录
首先，我们先来了解一下什么是优先级队列
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个最大元素
参考代码：
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 测试代码：
537
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
