堆的定义与操作

　　如题，堆的定义与操作。

#define MAXDATA 1000        /* 该值应根据具体情况定义为大于堆中所有可能元素的值 */

typedef struct HNode *Heap; /* 堆的类型定义 */
typedef int ElememntType;    /* 堆中的元素类型 */
struct HNode {
    ElementType *Data;        /* 存储元素的数组 */
    int Size;                /* 堆中当前元素个数 */
    int Cap;                /* 堆的最大容量 */
};    
typedef Heap MaxHeap;        /* 最大堆 */
typedef Heap MinHeap;         /* 最小堆 */

/* 以最大堆为例 */

MaxHeap CreateHeap(int MaxSize)
{
    MaxHeap H = (MaxHeap)malloc(sizeof(struct HNode));
    /* 堆中元素下标从 1 开始 */
    H->Data = (ElementType*)malloc( (MaxSize+1) * sizeof(ElementType) );
    H->Size = 0;
    H->Cap = MaxSize;
    H->Data[0] = MAXDATA;  /* 设置 "岗哨" ，大于 堆中所有可能元素的值 */
    
    return H;
} 

int IsFull(MaxHeap H)
{
    return ( H->Size == H->Cap );
}

int IsEmpty(MaxHeap H) 
{
    return ( H->Size == 0 );
}

void Insert(MaxHeap H, ElementType X)
{    /* 将 X 插入到 堆 H 中，调整以符合最大堆的特性 */
    /* 其中 H->Data[0] 已经定义为哨兵 */
    int i;
    if ( IsFull(H) ) return; // 堆已满 
    
    i = ++H->Size;
    for ( ; H->Data[i/2] < X; i/=2 ) 
        H->Data[i] = H->Data[i/2]; // 上滤 X 
    H->Data[i] = X; // 将 X 插入 
}

ElementType DeleteMax(MaxHeap H)
{/* 从最大堆H中取出键值最大的元素，并删除一个节点 */
    int Parent, Child;
    ElementType MaxItem, X;
    
    /* 这里省略判断堆是否已满的代码 */ 
    
    MaxItem = H->Data[1];     /* 取出根节点存放的最大值 */
    /* 用 最大堆中最后一个元素从根节点开始向上过滤下层节点 */
    X = H->Data[H->Size--]; /* 注意：当前堆的规模要减小 */
    for ( Parent = 1; Parent*2 <= H->Size; Parent=Child ) {
        Child = Parent * 2;
        if ( (Child != H->Size) && (H->Data[Child] < H->Data[Child+1]) )
            Child++; /* Chile 指向左右子节点的较大者 */
        if ( X >= H->Data[Child]  ) break; /* 找到了合适位置 */ 
        else /* 下滤X */ 
            H->Data[Parent] = H->Data[Child];
    }
    H->Data[Parent] = X;
    
    return MaxItem; 
}
/* -------------建最大堆------------- */
void PercDown(MaxHeap H, int p) 
{/* 下滤：将 H 中以 H->Data[p] 为根的子堆调整为最大堆 */ 
    int Parent, Child;
    ElementType X;
    
    X = H->Data[p]; /* 取出根节点存放的值 */
    for ( Parent = 1; Parent*2 <= H->Size; Parent=Child ) {
        Child = Parent * 2;
        if ( Child != H->Size && H->Data[Child] < H->Data[Child+1] )
            Child++; /* Chile 指向左右子节点的较大者 */
        if ( X >= H->Data[Child]  ) break; /* 找到了合适位置 */ 
        else /* 下滤X */ 
            H->Data[Parent] = H->Data[Child];
    }
    H->Data[Parent] = X;
} 

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