目录
首先,我们先来了解一下什么是优先级队列
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 测试代码: