优先队列（堆）

      普通的队列是一种先进先出的数据结构，元素在队列尾追加，在队头删除。在优先队列中，元素被赋予优先级，当访问元素时，具有最高优先级的元素最先删除。

      优先队列允许至少下列两种操作的数据结构：Insert(插入)、DeleteMin(删除最小者)，它的工作是找出、返回和删除优先队列中最小的元素。Insert相当于入队，而DeleteMin相当于出队。

      优先队列可以应用于外部排序、贪婪算法中实现优先队列通过反复求出最小元进行计算等。

堆的结构

      堆是一棵被全完填满的二叉树。一棵高为h的二叉树有 2^h 到 2^(h+1)-1 个节点。下图是一个完全二叉树：

图1   一棵完全二叉树

      完全二叉树的的高是[ logN ]，显然它是O(logN).

      完全二叉树的规律性，因此它可以用一个数组表示。对于数组中任一位置i上的元素，其左儿子在位置2i上，右儿子在左儿子后的单元（2i+1）上，它的父亲则在i/2上。

                                                                             图2   完全二叉树的数组实现

堆数据结构组成：一个数组、一个代表最大值的整数、当前的堆大小

主要操作

Insert（插入）

       为将一个元素X插入到堆中，我们在下一个空闲位置创建一个空穴，否则该堆将不是完全树。如果X可以放在该空穴中而不破坏堆的序，那么插入完成。否则，我们把空穴的父节点上的元素移入该穴中，这样，空穴就朝着根的方向上行一步。继续该过程直到X能被放入空穴中为止。这种一般的策略叫做上滤，新元素在堆中上滤直到找出正确的位置。

       如果欲插入的元素是新的最小元从而一直上滤到根处，插入的时间复杂度为O(logN)。

DeleteMin（删除）

       删除一个最小元，在根节点处产生了一个空穴。由于现在堆少了一个元素，因此堆中最后一个元素X必须移动到该堆的某个地方。如果X可以被放到空穴中，那么DeleteMin完成。不过这一般不太可能，因此我们将空穴的两个儿子中较小者移入空穴，这样就把空穴向下推了一层。重复该步骤知道X可以被放入空穴中。因此，我们的作法是将X置入沿着从根开始包含最小儿子的一条路径上的一个正确的位置。

      该算法的最坏情形运行时间为O(logN)。平均而言，被放到根处的元素几乎下滤到堆的底层，因此平均运行时间为O(logN)。

BuildHeap（构建堆）

      BuildHeap(H)操作把N个关键字作为输入并把它们放入空堆中。这可以使用N个相继的Insert操作来完成。由于每个Insert将花费O(1)平均时间以及O(logN)的最坏情形时间，因此该算法总的运行时间则是O(N)平均时间而不是O(NlogN)最坏情形时间。

      一般的算法是将N个关键字以任意顺序放入树中，保持结构特性。此时，如果percolateDown(i)从节点i下滤，那么将创建一棵具有堆序的树：

for( i =N/2; i>0; i--)
      PercolateDown(i);

例程

#include<stdio.h>

static int MinSize = 100;   //堆大小
typedef struct heapStruct {
	int capacity;
	int Size;
	int *value;
}HeapStruct;

int IsFull(HeapStruct*);
int IsEmpty(HeapStruct*);

void error(char *message)
{
	fputs(message,stderr);
	fputc('\0',stderr);
	exit(1);
}

HeapStruct* Initialize(int MaxElements)        //初始化一个堆
{
	HeapStruct *H;
	if (MaxElements < MinSize)
		error("MaxElements is too small");
	
	H = (HeapStruct*)malloc(sizeof(HeapStruct));
	if (H == NULL)
		error("error of malloc for H");
	
	H->value = (int*)malloc(MaxElements*sizeof(int));
	if (H->value == NULL)
		error("error of malloc for H->value");

	H->capacity = MaxElements;
	H->Size = 0;
	H->value[0] = 0;
	return H;
}

void Insert(int x, HeapStruct *H)    //堆的插入操作
{
	int i;
	if (IsFull(H))
		error("H is full");
	for (i = ++H->Size; H->value[i / 2] > x; i = i / 2)
		H->value[i] = H->value[i/2];
	H->value[i] = x;
}

int DeleteMin(HeapStruct *H)   //堆的删除操作
{
	int i, child;
	int min, last;

	if (IsEmpty(H))
		error("The H is empty");
	min = H->value[1];
	last = H->value[H->Size--];

	for (i = 1; i * 2 <= H->Size; i = child)
	{
		child = 2 * i;
		if (child != H->Size && H->value[child + 1] < H->value[child])
			child++;
		if (last > H->value[child])
			H->value[i] = H->value[child];
		else
			break;
	}
	H->value[i] = last;
	return min;
}