数据结构--优先级队列

优先级队列：优先级队列 是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。（优先权可根据具体形势具体定义）

优先级对列是堆的应用之一， 它的具体实现以堆为原型。

仿函数:

<span style="font-size:18px;">//仿函数比较小
template<class T>
struct Less
{
bool operator() (const T& l, const T& r)
{
return l < r;
}
};
//仿函数比较大
template<class T>
struct Greater
{
bool operator() (const T& l, const T& r)
{
return l > r;
}
};</span>

堆：

<span style="font-size:18px;">//template<class T, class Compare = Less<T>>
//适配器模式  默认为Less比较模式
template<class T, template<class> class Compare = Less>
class Heap
{
public:
//无参构造函数
Heap()
{}
//带参
Heap(const T* a, size_t size)
{
_a.reserve(size);  //先开辟空间
for (size_t i = 0; i < size; ++i)
{
_a.push_back(a[i]);  //push 数据
}

// 建堆
for (int i = (_a.size() - 2) / 2; i >= 0; --i)
{
_AdjustDown(i);  //从第一个非叶子节点下调
}
}
//
Heap(vector<T>& a)
{
_a.swap(a);  //交换两个vector

// 建堆
for (int i = (_a.size() - 2) / 2; i >= 0; --i)
{
_AdjustDown(i);
}
}

//插入数据
void Push(const T& x)
{
_a.push_back(x); //尾插

_AdjustUp(_a.size() - 1); //上调  从下向上进行调整
}
//pop数据
void Pop()
{

size_t size = _a.size();
assert(size > 0); //防御式编程

swap(_a[0], _a[size - 1]);  //交换两个数据
_a.pop_back();  //尾删
_AdjustDown(0);  //上调
}
//取堆顶元素
T& Top()
{
assert(!_a.empty());
return _a[0];
}

size_t Size()
{
assert(_a.size() > 0);
return _a.size();
}
bool Empty()
{
return _a.size() == 0;
}

void Print()
{
for (int i = 0; i < _a.size(); i++)
{
cout << _a[i] << "  ";
}
cout << endl;
}

protected:
//上调
void _AdjustUp(int child)
{
int parent = (child - 1) / 2;
//while(parent>=0)
while (child > 0)
{
Compare<T> com;  //会调用相应的仿函数进行比较，
//Compare com;
//if (_a[child] > _a[parent])
if (com(_a[child], _a[parent]))  //如果满足各自的条件，就进行交换，然后在继续
{
swap(_a[child], _a[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}

void _AdjustDown(size_t parent)
{
size_t child = parent * 2 + 1;
while (child < _a.size())
{
// 选出孩子里面大的那一个
//Compare com;
Compare<T> com;
//if (child+1 < _a.size() &&_a[child+1] > _a[child])
if (child + 1 < _a.size()
&& com(_a[child + 1], _a[child]))
{
++child;
}

// 如果父亲小于孩子，则交换并继续往下调整
// 否则调堆完成

//if(_a[child] > _a[parent])
if (com(_a[child], _a[parent]))
{
swap(_a[parent], _a[child]);
parent = child;
child = 2 * parent + 1;
}
else
{
break;
}
}
}

protected:

vector<T> _a;
};</span>

优先级对列：

<span style="font-size:18px;">//优先级队列  默认以小的优先级高
template <class T, template<class> class Compare = Less>
class PriorityQueue
{
public:
void Push(const T& x)
{
_hp.Push(x);
}

void Pop()
{
_hp.Pop();
}

T& Top()
{
return _hp.Top();
}

size_t Size()
{
return _hp.Size() ;
}
bool Empty()
{
return _hp.Size() == 0;
}

void Print()
{
_hp.Print();
}

protected:
Heap<T, Compare> _hp;
};
</span>

测试用例1：

<span style="font-size:18px;">void Test1()
{
int a[] = { 10, 11, 13, 12, 16, 18, 15, 17, 14, 19 };
PriorityQueue<int, Greater> p;
p.Push(10);
p.Push(11);
p.Push(13);
p.Push(12);
p.Push(16);
p.Push(18);
p.Push(15);
p.Push(17);
p.Push(14);
p.Push(19);
p.Print();
cout << p.Empty() << endl;
cout << p.Size() << endl;
cout << p.Top() << endl;
}
</span>

测试用例2：

<span style="font-size:18px;">void Test2()
{
int a[] = { 10, 11, 13, 12, 16, 18, 15, 17, 14, 19 };
PriorityQueue<int, Greater> p;
p.Push(10);
p.Push(11);
p.Push(13);
p.Push(12);
p.Push(16);
p.Push(18);
p.Push(15);
p.Push(17);
p.Push(14);
p.Push(19);

p.Print();
p.Pop();
p.Print();
p.Pop();
p.Print();
p.Pop();
p.Print();
p.Pop();
p.Print();
p.Pop();
p.Print();
p.Pop();
p.Print();
p.Pop();
p.Print();
p.Pop();
p.Print();
p.Pop();
p.Print();
p.Pop();
p.Print();

}</span>

仿函数测试用例：

<span style="font-size:18px;">void TestFuner()
{
Less<int> less;
cout << less(1, 2) << endl;
cout << less(3, 2) << endl;
cout << less(4, 2) << endl;
cout << less(-1, 2) << endl;
cout << "-------" << endl;;
Greater<int> greater;
cout << greater(1, 2) << endl;
cout << greater(3, 2) << endl;
cout << greater(4, 2) << endl;
cout << greater(-1, 2) << endl;
}
</span>