二叉堆的实现C语言

二叉堆就是一颗完全二叉树。又根据父节点与子节点的大小关系分为最大堆，最小堆。
今天学习的是最小堆，就写最小堆吧。
 最小堆的概念是：每一个父节点都小于他的子节点，所以根就是整个堆的最小值。
由于二叉堆是由一颗完全二叉树实现的，所以可以用一个数组来表示一个堆。对于数组中位置i
处的元素，其父节点就是下表为i/2的元素，其左儿子节点就是下标位i*2处的元素，右儿子就是左儿子下标加1。
下面是声明

struct Heap;
typedef struct Heap *PariorityQueue;
struct Heap
{
	int MaxSize;            //这个是堆数组的最大空间。
	int Size;               //这个是堆当前下标所处位置
	int *Element;            //堆数组（这里用的是整数数组，实际上根据要求什么类型数组都可以都可以
};
<pre name="code" class="cpp">void exchange(int *s, int a, int b)//交换数组元素
{
	int temp;
	temp = s[a];
	s[a] = s[b];
	s[b] = temp;
}
int IsEmpty(PariorityQueue p)//判断堆是否为空
{
	return p->Size == 0;
}
int IsFull(PariorityQueue p)//判断堆满
{
	return p->MaxSize == p->Size;
}
 

PariorityQueue Creat(int Maxsize)//创建一个空堆
{
	PariorityQueue p;
	p = (PariorityQueue)malloc(sizeof(struct Heap));
	if (p == NULL)
	{
		printf("No apace\n");
		return NULL;
	}
	p->Element = (int*)malloc(sizeof(int)*Maxsize);
	if (p->Element == NULL)
	{
		printf("out of heap space\n");
	}
	p->MaxSize = Maxsize;
	p->Size = 0;
	p->Element[0] =INT_MIN;             //堆得存储从下标1开始，0处放一个哨兵，用来检测到没到堆顶。
	return p;
}
//接下来是插入的例程，插入一个新的数，,size+1,因为他有可能破坏的堆的有序性，所以需要进行一系列和父亲节点的比较，来把新插入的树放到合适的位置。
<pre name="code" class="cpp">void Insert(int x, PariorityQueue p)//插入
{
	if (IsFull(p))
	{
		printf("Heap is full\n");
		return;
	}
	int i;
	for (i = ++p->Size; p->Element[i / 2] > x; i /= 2)     //下标加1，然后插入的元素和当前结点的父节点比较，因为之前的堆是有序的，只要比x大，就一直向上。直到找到x合适的插入位置为止。
	{
		p->Element[i] = p->Element[i / 2];
	}
	p->Element[i] = x;
}

//接下来是取出堆顶的元素，即这个堆中的最小值。

int DeleteMin(PariorityQueue p)
{
	if (IsEmpty(p))
	{
		printf("heap is empty\n");
		return ERROR;
	}
	int min, last;
	min = p->Element[1];                //保存堆顶元素，用于return
	last = p->Element[p->Size--];      //保存最后一个元素，因为取出一个元素，所以size-1
	int i,child;
	for (i = 1; i * 2 < p->Size; i=child)                                          //从根节点开始，寻找最小值
	{
		child = i*2;                                                     //找儿子中的最小值
		if (child != p->Size&&p->Element[child + 1] < p->Element[child])
			child++;                                                       //比较儿子中较小的一个
		if (last > p->Element[child])                               //给堆最后一个元素寻找合适的位置
			p->Element[i] = p->Element[child];                       //把儿子中较小的一个赋给父节点。
		else                    //直到找到两个儿子都比last大，退出循环，赋值
			break;
	}
	p->Element[i] = last;
	return min;
}

接下来是降低堆中某个元素的值。由于降低该关键字的值，会导致堆得有序性被破坏，所以会有一个函数来专门处理这件事。

void DecreaseKey(PariorityQueue p, int  decrement, int index)//减少关键字的值
{
	if (index > p->Size || index < 1)
	{
		printf("下标不准确\n");
		return;
	}
	p->Element[index] -= decrement;
	PercolateUp(p, index);
}
void PercolateUp(PariorityQueue p, int count)//上滤操作
{
	int i;
	for (i = count / 2; i > 0; i /= 2)                  //由于降低了该下标的值，所以从他开始，向上挨个与父节点比较，直到找到比他小的为止。
	{
		if (p->Element[count] > p->Element[i])
			break;
		exchange(p->Element, count, i);
		count = i;
	}
}

与上面对应，还有增加关键字的值。
void IncreaseKey(PariorityQueue p, int incremental, int index)//加量
{
    if (index>p->Size || index<1)
    {
        printf("failed increaseKey, since overstep the boundary!\n ");
        return;
    }
    p->Element[index] += incremental;
    MinHeapFit(p, index);
}
void MinHeapFit(PariorityQueue p, int count)       //下滤操作
{
    int i;
    for (i = count * 2; i <= p->Size; i *= 2)
    {
        if (p->Element[count] < p->Element[i])
            break;
        if (p->Element[i] > p->Element[i + 1])
            i++;
        exchange(p->Element, i, count);
        count = i;
    }
}

还有个Delete函数，删除某个节点，这个函数先用上面的降低关键字的值，把他减少到足以放到堆顶，然后执行取出堆顶元素的值就可以了。
如有错误，还请指正。谢谢。