#include<vector>
#include<list>
#include<stack>
using namespace std;
namespace Ljw
{
//自己构造仿函数
template<class T>
class Less
{
public:
bool operator()(T&x,T&y)
{
return x < y;
}
};
//偏特化
template<class T>
class Less<T*>
{
public:
bool operator()(const T* x, const T* y)
{
return *x < *y;
}
};
template<class T>
class Greater
{
public:
bool operator()(T& x, T& y)
{
return x > y;
}
};
template<class T>
class Greater<T*>
{
public:
bool operator()(const T* x, const T* y)
{
return *x > *y;
}
};
//仿函数,小于
//template<class T, class Container = vector<int>,class Compare=std::less<T>>//库里小于比较
//template<class T, class Container = vector<int>, class Compare = Less<T>>
//template<class T, class Container = vector<int>, class Compare = std::greater<T>>//库里大于比较
template<class T, class Container = vector<int>, class Compare = Greater<T>>
//优先级队列中,默认大堆,默认less<int>
class priority_queue
{
public:
//默认大堆,向下遍历(是指从最后一个节点到第一个节点都向下遍历一遍)
void Adjustdown(int parent)
{
Compare com;//创建一个对象
//找孩子大的那一个,先默认左孩子最大
int child = parent * 2 + 1;
while (child < _con.size())
{
//再与右孩子对比
//child+1<_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 (com(_con[parent], _con[child]))
{
swap(_con[child], _con[parent]);
//向下遍历,向下更新一下孩子和父亲
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
//向上调整
void Adjustup(int child)
{
Compare com;//创建一个对象
int parent = (child - 1) / 2;
while (child>0)//等于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;
}
}
}
//无参默认构造
priority_queue()
{}
//int a[]={1,2,3,4}
template<class InputTterator> //priority_queue<int>pq(a,a+3);打印pq,是有序
priority_queue(InputTterator first, InputTterator last)//迭代器
{ //默认大堆
while (first != last)
{
_con.push_back(*first);
first++;
}
//向下遍历
//-1是下标
for (int i = (_con.size() - 1 - 1); i >= 0; i--)
{
Adjustdown(i);//向下遍历
}
}
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()
{
return _con[0];
}
bool empty()
{
return _con.empty();
}
private:
Container _con;
};
void test1()
{
//这是小堆,less是小于比较,但是是大堆
priority_queue<int,vector<int>,std::greater<int>> pq;
pq.push(1);
pq.push(3);
pq.push(2);
pq.push(4);
pq.push(2);
while(!pq.empty())
{
cout << pq.top() << " ";
pq.pop();
}
cout << endl;
priority_queue<int> pq1;
pq1.push(1);
pq1.push(3);
pq1.push(2);
pq1.push(4);
pq1.push(2);
while (!pq1.empty())
{
cout << pq1.top() << " ";
pq1.pop();
}
}
}
#include<iostream>
using namespace std;
#include"Priority_queue.h"
int main()
{
Ljw::test1();
return 0;
}