5.1 Heap - Definition and Operation of Heap

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

typedef struct HeapStruct *MaxHeap;
struct HeapStruct{
    ElementsType *Elements;
    int ESize;
    int Capacity;
};

bool isFull(MaxHeap H)
{
    return (H->ESize == H->Capacity);
}

bool isEmpty(MaxHeap H){
    return (H->ESize == 0);
}

MaxHeap Create(int MaxSize)
{
    MaxHeap H = malloc(sizeof(struct HeapStruct));
    H->Elements = malloc((MaxSize + 1) * sizeof(ElementsType));
    H->ESize = 0;
    H->Capacity = MaxSize;
    H->Elements[0] = MaxData;
    return H;
}

void Insert(MaxHeap H, ElementsType item)
{  //T(N) = O(logN)
    int i;
    if(isFull(H)){
        printf( " Max heap is full\n " );
         return ;
    }
    i = ++H->ESize;
    for( ; H->Elements[i / 2] < item; i /= 2)
        H->Elements[i] = H->Elements[i / 2];
    H->Elements[i] = item;
}

ElementsType DeleteMax(MaxHeap H)
{
    int Parent, Child;   // Position marker 
    ElementsType MaxItem, temp;
     if (isEmpty(H)){
        printf( " Max heap is empty\n " );
         return ;
    }
    MaxItem = H->Elements[1];
    temp = H->Elements[H->ESize];
    H ->ESize-- ;
     for (Parent = 1 ; Parent * 2 <= H->ESize; Parent = Child){
         // As long as the current position (pointed to by Parent) has a child node, continue to loop to judge 
        Child = Parent * 2 ;
         if (Child != H->ESize && (H->Elements[Child] < H->Elements[Child + 1 ]))
            Child++;
        if(temp >= H->Elements[Child])
            break;
        else
            H->Elements[Parent] = H->Elements[Child];
    }
    H->Elements[Parent] = temp;
    return MaxItem;
}

void PrecDown(MaxHeap H, int p)
{
    int Parent, Child;
    ElementsType X;
    X = H->Elements[p];
    for(Parent = p; Parent * 2 <= H->ESize; Parent = Child){
        Child = Parent * 2;
        if(Child != H->ESize && (H->Elements[Child] < H->Elements[Child + 1]))
            Child++;
        if(X >= H->Elements[Child])
            break;
        else
            H->Elements[Parent] = H->Elements[Child];
    }
    H->Elements[Parent] = X;
}

void BuildHeap(MaxHeap H)
{   // Assume that all H->ESize elements already exist in H->Elements[] 
    int i;
     for (i = H->ESize / 2 ; i > 0 ; i++)   // From the parent node of the last node Start, to root node 1 
        PrecDown(H, i);
}