[PTA] Percolate Up and Down

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

typedef int ElementType;
#define MinData -1

typedef struct HeapStruct *PriorityQueue;
struct HeapStruct {
    ElementType  *Elements;
    int Capacity;
    int Size;
};

PriorityQueue Initialize( int MaxElements ); /* details omitted */

void PercolateUp( int p, PriorityQueue H );
void PercolateDown( int p, PriorityQueue H );

void Insert( ElementType X, PriorityQueue H ) 
{
    int p = ++H->Size;
    H->Elements[p] = X;
    PercolateUp( p, H );
}

ElementType DeleteMin( PriorityQueue H ) 
{ 
    ElementType MinElement; 
    MinElement = H->Elements[1];
    H->Elements[1] = H->Elements[H->Size--];
    PercolateDown( 1, H );
    return MinElement; 
}

PriorityQueue Initialize( int MaxElements )
{
	PriorityQueue p;
	p=(PriorityQueue)malloc(sizeof(struct HeapStruct));
	p->Elements=(int*)malloc(sizeof(int)*MaxElements);
	p->Capacity=MaxElements;
	p->Size=0;
	p->Elements[0]= MinData;
	return p;
}

void PercolateUp( int p, PriorityQueue H )
{
	int tmp=H->Elements[p];
	for(;H->Elements[p/2]>tmp;p/=2){
		H->Elements[p]=H->Elements[p/2];
	}
	H->Elements[p]=tmp;
}

void PercolateDown( int p, PriorityQueue H )
{
	int child;
	int tmp=H->Elements[1];
	for(;2*p<H->Size;p=child){
		child=2*p;
		if(child!=H->Size-1&&H->Elements[child+1]<H->Elements[child]){
			child++;
		}
		if(H->Elements[child]<tmp)H->Elements[p]=H->Elements[child];
		else break;
	}
	H->Elements[p]=tmp;
}

int main()
{
    int n, i, op, X;
    PriorityQueue H;

    scanf("%d", &n);
    H = Initialize(n);
    for ( i=0; i<n; i++ ) {
        scanf("%d", &op);
        switch( op ) {
        case 1:
            scanf("%d", &X);
            Insert(X, H);
            break;
        case 0:
            printf("%d ", DeleteMin(H));
            break;
        }
    }
    printf("\nInside H:");
    for ( i=1; i<=H->Size; i++ )
        printf(" %d", H->Elements[i]);
    return 0;
}