堆的操作和定义（大顶堆为例）

• Insert( ): 堆的插入，为保证堆的完全二叉树的性质，新加入的元素放到数组最末尾，然后向上过滤节点，保证其有序性。
• DeleteMax( ): 拿走根节点的最大元素，为保证堆的完全二叉树的性质，拿数组最末尾的元素替换根节点元素，然后向下过滤节点，保证其有序性。
• BuildHeap( ): 给定已知的数组，建立最大堆，从n/2 点开始过滤，然后n/2 -1， n/2-2, 这样才能保证每次过滤的节点的左右子树都已经是堆。调用PercDown( )， 时间复杂度O(n)。
• PercDown( ): 向下过滤节点函数，保证堆的有序性。前提：左右子树都是堆，然后根节点向下过滤。

#include <stdio.h>
#include <stdlib.h>

//最大堆的创建
#define MaxData 999
#define ERROR -1 /* 错误标识应根据具体情况定义为堆中不可能出现的元素值 */
typedef int ElementType;
typedef struct HeapStruct *MaxHeap;
struct HeapStruct{
        ElementType *Elements; /*存储堆元素的数组*/
        int Size;  /*堆当前元素个数*/
        int Capacity;/*堆的最大容量*/
};


MaxHeap Create(int MaxSize)
{   //创建容量为maxsize的空的最大堆
    MaxHeap H=malloc(sizeof(struct HeapStruct));
    H->Elements=malloc((MaxSize+1)*sizeof(ElementType));/*数组下标0处不放元素*/
    H->Size=0;
    H->Capacity=MaxSize;
    H->Elements[0]=MaxData;/*定义哨兵大于堆中所有元素，便于后续操作*/
    return H;
}

int IsFull(MaxHeap H)
{
    if(H->Capacity==H->Size) return 1;
    else return 0;
}
void Insert(MaxHeap H, ElementType item)
{
    int i;
    if(IsFull(H)){
        printf("最大堆已满");
        return;
    }
    i=++H->Size;/*i指向插入后堆中的最后一个元素的位置*/
    for(;H->Elements[i/2]<item;i/=2)
        H->Elements[i]=H->Elements[i/2]; /*向上过滤结点*/
    H->Elements[i]=item;
}
int IsEmpty(MaxHeap H)
{
    return H->Size==0?1:0;
}
ElementType DeleteMax(MaxHeap H)
{   /*最大堆H中取出键值为最大的元素，并删除一个节点，为了保持树的平衡性*/
    int Parent,Child;
    ElementType MaxItem, temp;
    if(IsEmpty(H)){
        printf("最大堆已为空");
        return ERROR;
    }
    MaxItem=H->Elements[1];
    /*用最大堆的最后一个元素从根结点开始向上过滤下层结点*/
    temp=H->Elements[H->Size--];
    for(Parent=1;Parent*2<=H->Size;Parent=Child){
        Child=Parent*2;
        if((Child!=H->Size)&&(H->Elements[Child]<H->Elements[Child+1]))
            Child++;/*Child指向左右子结点较大者*/
        if(temp>=H->Elements[Child]) break;
        else
            H->Elements[Parent]=H->Elements[Child];
    }
    H->Elements[Parent]=temp;
    return MaxItem;
}

/*----------- 建造最大堆 -----------*/
void PercDown( MaxHeap H, int p )
{ /* 下滤：将H中以H->Data[p]为根的子堆调整为最大堆 */
    int Parent, Child;
    ElementType X;
    X = H->Elements[p]; /* 取出根结点存放的值 */
        for( Parent=p; Parent*2<=H->Size; Parent=Child ) {
        Child = Parent * 2;
        if( (Child!=H->Size) && (H->Elements[Child]<H->Elements[Child+1]) )
            Child++;  /* Child指向左右子结点的较大者 */
        if( X >= H->Elements[Child] ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            H->Elements[Parent] = H->Elements[Child];
    }
    H->Elements[Parent] = X;
}

void BuildHeap( MaxHeap H )
{ /* 调整H->Data[]中的元素，使满足最大堆的有序性  */
  /* 这里假设所有H->Size个元素已经存在H->Data[]中 */
     int i;
         /* 从最后一个结点的父节点开始，到根结点1 */
     for( i = H->Size/2; i>0; i-- )
        PercDown( H, i );
}