堆&优先级队列
本文要点：
1.堆的实现
3.利用堆实现优先级队列
一、堆
1.堆是一种数组对象，可以被看作一颗完全二叉树结构，堆结构的二叉树存储是一种静态存储。
堆又被分为大堆和小堆：
大堆：每个父节点大于子节点
小堆：每个父节点小于子节点
2.堆的实现（以大堆为例）
实现一个堆主要在于要建堆和调整。
假设现有数组int a[] = { 10, 16, 18, 12, 11, 13, 15, 17, 14, 19 }，a的大堆表示
建堆：也就是将数字插入数组对象中（这里我们用迭代器实现）
调整：首先要从堆数组的尾部开始找到第一个非叶子结点，从该位置开始调整，将左右孩子以及父节点中大的放在父节点的位置，然后继续调整数组的前一个位置的数字。这种挑这个方式也叫做向下调整。
由于堆存在大顶堆和小顶堆两种结构，因此为了提高代码的复用性，这里我们用仿函数来实现
template
struct Less
{
bool operator()(const T& left,const T& right)
{
return left < right;
}
};
template
struct Greater
{
bool operator()(const T& left,const T& right)
{
return left > right;
}
};
//堆
template> //默认为大堆
class Heap
{
public:
Heap()
{}
Heap(T* a,int size)
{
assert(a);
_heap.reserve(size);
for(int i=0; i=0; --j) //从下向上，找到第一个非叶子结点
{
AdjustDown(j);
}
}
void Push(const T& x)
{
_heap.push_back(x); //在最后插入一个数字
AdjustUp(_heap.size()-1); //从最后插入数字的位置向上调整
}
void Pop()
{
assert(!_heap.empty());
swap(_heap[0],_heap[_heap.size()-1]); //交换堆顶与最后一个元素
_heap.pop_back(); //删除最后一个元素(删除了堆顶的元素)
AdjustDown(0); //从第一个数向下调整
}
bool Empty()
{
return _heap.empty();
}
size_t Size()
{
size_t sz = _heap.size();
return _heap.size();
}
const T& Top()
{
return _heap[0];
}
void Display()
{
for (size_t i=0; i _heap[child])*/
if ((child+1) < _heap.size()
&& com(_heap[child+1],_heap[child]))
{
++child;
}
//选父节点与孩子节点中较大的一个
/*if (_heap[child] > _heap[parent])*/
if (com(_heap[child],_heap[parent]))
{
swap(_heap[parent],_heap[child]);
parent = child;
child = parent * 2 + 1;
}
else
break;
}
}
void AdjustUp(int child) //向上调整
{
int parent = (child-1)/2;
while(child > 0)
{
Compare com;
//if (_heap[child] > _heap[parent]) //孩子结点大于父节点就交换
if(com(_heap[child],_heap[parent]))
{
swap(_heap[child],_heap[parent]);
child = parent;
parent = (child-1)/2;
}
else
break;
}
}
protected:
vector _heap;
}; 二、优先级队列
优先级队列实现的操作有删除、插入，每次从队列中取出的都是具有最高优先级的元素。还是以上述数组为例，那么每次取最大的值就是取优先级最高的元素。
· 假如是一组无序数组，每次进行插入时，我们可以在数组的尾部直接插入，但是删除时就必须进行查找，找出最大的数以后才能删除这个数。那么，插入的时间复杂度为O(1)，删除的时间复杂度为O(N)
· 假如是一组有序数组，插入时需将插入的数x放到正确位置，时间复杂度为O(N)，删除时，可以直接删除数组的第一个元素（或最后一个元素），时间复杂度O(1)
但是这两种方法都不是最好的，当N值特别大时，这两种方法的效率都很低。因此我们借用堆特有的性质就可以实现优先级队列了！
删除：直接删除堆顶元素，然后进行向上调整使其重新称为一个大堆------O(N*lgN)
插入：插到堆数组最后，进行向下调整------O(N*lgN)
//优先级队列
template>
class PriorityQueue
{
public:
PriorityQueue(T* a,int size)
:_pq(a,size)
{}
void Push(const T& x)
{
_pq.Push(x);
}
void Pop()
{
_pq.Pop();
}
const T& Top()
{
return _pq.Top();
}
void Display()
{
_pq.Display();
}
protected:
Heap _pq;
};
void TestPriorityQueue()
{
int a[] = { 10, 16, 18, 12, 11, 13, 15, 17, 14, 19 };
int sz = sizeof(a)/sizeof(a[0]);
PriorityQueue> pq1(a,sz);
cout<<"大堆： ";
pq1.Display();
cout<<"Top: "<