一、priority_queue的介绍
1、优先级队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是他所包含的元素中最大的。
2、优先级队列类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素（优先级队列中位于顶部的元素）。
3、优先级队列被实现为容器适配器，容器适配器就是将特定的容器类封装作为其底层容器类，提供一组特定的成员函数来访问其元素。
4、底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该支持随机访问、迭代器访问，并支持以下操作：
- empty()
- size()
- front()
- push_back()
- pop_back()
5、标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。
6、需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和
pop_heap来自动完成此操作。
二、priority_queue的使用
优先级队列默认使用vector作为其底层存储数据的容器，在vectoe上又使用了堆算法将vector中的元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的地方，都可以考虑使用priority_queue。注意：默认情况下priority_queue是大堆。
函数声明 | 接口说明 |
构造函数 | |
判断优先级队列是否为空，为空返回true，否则返回flase | |
返回优先级队列里元素的个数 | |
返回堆顶元素 | |
删除堆顶元素 | |
插入元素 |
注意：
①默认情况下，priority_queue是大堆。
#include <functional>//greater算法的头文件
void Test4()
{
vector<int> v{ 9,4,2,3,7,1,6,5,8 };
//默认情况下，创建的是大堆
priority_queue<int> q1(v.begin(), v.end());
cout << "大堆：";
while (!q1.empty())
{
cout << q1.top() << " ";
q1.pop();
}
cout << endl;
//如果想要建小堆需要将第三个模板参数换成greater
priority_queue<int, vector<int>, greater<int>> q2(v.begin(), v.end());
cout << "小堆：";
while (!q2.empty())
{
cout << q2.top() << " ";
q2.pop();
}
cout << endl;
}
②如果在priority_queue中放自定义类型的数据，用户需要在自定义类型中提供>或者<的重载。
三、仿函数
这就是一个仿函数，这是一个比较大小的仿函数，它重载了一个非常特殊的运算符——()。
class greater
{
public:
bool operator() (const int& x, const int& y)
{
return x > y;
}
};我们可以这样使用仿函数，com是一个对象，但是它能够像函数一样被使用，我们把这种对象称之为函数对象。也就是说一个类只要重载了()运算符就可以被称为仿函数。
void Test5()
{
int a = 3, b = 13;
lsx::greater com;//函数对象
cout << com(a, b);
}加上模板就更加完美了
template<class T>
class greater
{
public:
bool operator() (const T& x, const T& y)
{
return x > y;
}
};仿函数的出现就是为了替代函数指针。
接下来在priority_queue的模拟实现中就需要使用仿函数。
四、priority_queue的模拟实现
1、两个仿函数
template<class T>
class greater
{
public:
bool operator() (const T& x, const T& y)
{
return x > y;
}
};
template<class T>
class less
{
public:
bool operator() (const T& x, const T& y)
{
return x < y;
}
};2、向下调整函数
void AdjustDown(size_t parent)
{
Compare _com;//定义函数对象
size_t child = parent * 2 + 1;
while (child < _con.size())//向下调整
{
if (child + 1 < _con.size() && _com(_con[child], _con[child + 1]))
{
++child;
}
if (_com(_con[parent], _con[child]))
{
swap(_con[parent], _con[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}3、向上调整函数
void AdjustUp(size_t child)
{
Compare _com;//定义函数对象
size_t parent = (child - 1) / 2;
while (child > 0)//向上调整
{
if (_com(_con[parent], _con[child]))
{
swap(_con[parent], _con[child]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}4、构造函数
priority_queue(){}//默认构造函数
template<class InputIterator>
priority_queue(InputIterator first, InputIterator last)//迭代器区间构造
:_con(first,last)
{
for (int i = (_con.size() - 1 - 1) / 2;i >= 0;i--)//建堆
{
AdjustDown(i);
}
}5、功能函数
void push(const T& x)
{
_con.push_back(x);
AdjustUp(_con.size() - 1);
}
void pop()
{
swap(_con[0], _con[_con.size() - 1]);
_con.pop_back();
AdjustDown(0);
}
const T& top()const
{
return _con[0];
}
size_t size()const
{
return _con.size();
}
bool empty()const
{
return _con.empty();
}6、全部代码
#include<iostream>
#include<vector>
using namespace std;
namespace lsx
{
template<class T>
class greater
{
public:
bool operator() (const T& x, const T& y)
{
return x > y;
}
};
template<class T>
class less
{
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)//迭代器区间构造
:_con(first,last)
{
for (int i = (_con.size() - 1 - 1) / 2;i >= 0;i--)//建堆
{
AdjustDown(i);
}
}
void AdjustDown(size_t parent)
{
Compare _com;
size_t child = parent * 2 + 1;
while (child < _con.size())
{
if (child + 1 < _con.size() && _com(_con[child], _con[child + 1]))
{
++child;
}
if (_com(_con[parent], _con[child]))
{
swap(_con[parent], _con[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void AdjustUp(size_t child)
{
Compare _com;
size_t parent = (child - 1) / 2;
while (child > 0)
{
if (_com(_con[parent], _con[child]))
{
swap(_con[parent], _con[child]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
void push(const T& x)
{
_con.push_back(x);
AdjustUp(_con.size() - 1);
}
void pop()
{
swap(_con[0], _con[_con.size() - 1]);
_con.pop_back();
AdjustDown(0);
}
const T& top()const
{
return _con[0];
}
size_t size()const
{
return _con.size();
}
bool empty()const
{
return _con.empty();
}
private:
Container _con;
};
}
