二叉树大堆代码

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef struct Heap
{
    int* a;
    int size;
    int capacity;
}Heap;

void Swap(int* e1, int* e2);
void InitHead(Heap* php);
void DestroyHeap(Heap* php);
void PushHeap(Heap* php, int x);
void AdjustUp(int* a, int child);
void PopHeap(Heap* php);
void AdjustDown(int* a, int parent, int n);

#include "FileName.h"

void Swap(int* e1, int* e2)
{
    int p = *e1;
    *e1 = *e2;
    *e2 = p;
}

void InitHeap(Heap* php)
{
    assert(php);
    php->a = NULL;
    php->capacity = 0;
    php->size = 0;
}

void DestroyHeap(Heap* php)
{
    assert(php);
    free(php->a);
    php->a = NULL;
    php->capacity = 0;
    php->size = 0;
}

void AdjustUp(int* a, int child)
{
    assert(a);
    while (child)
    {
        int parent = (child - 1) / 2;
        if (a[child] > a[parent])
        {
            Swap(&a[child], &a[parent]);
            child = parent;
        }
        else
        {
            break;
        }
    }
}

void PushHeap(Heap* php, int x)
{
    assert(php);
    if (php->capacity == php->size)
    {
        int count = php->capacity == 0 ? 4 : php->capacity * 2;
        int* temp = (int*)realloc(php->a, count * sizeof(int));
        if (temp == NULL)
        {
            perror("temp realloc");
            exit(1);
        }
        php->a = temp;
        php->capacity = count;
    }
    php->a[php->size++] = x;
    AdjustUp(php->a, php->size - 1);
}

void AdjustDown(int* a, int parent, int n)
{
    assert(a);
    int child = parent * 2 + 1;
    while (child < n)
    {
        if (child + 1 < n && a[child] < a[child + 1])
        {
            child++;
        }
        if (a[child] > a[parent])
        {
            Swap(&a[child], &a[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }
    }
}

void PopHeap(Heap* php)
{
    assert(php && php->size);
    Swap(&php->a[0], &php->a[php->size - 1]);
    php->size--;
    AdjustDown(php->a, 0, php->size);
}

int main()
{
    int num[] = { 1, 2, 9, 3, 6, 0, 5 };
    int len = sizeof(num) / sizeof(num[0]);
    for (int i = (len - 2) / 2; i >= 0 ; i--)
    {
        AdjustDown(num, i, len);
    }
    len--;
    int k = 0;
    printf("k = ");
    scanf_s("%d", &k);
    while (k--)
    {
        printf("%d ", num[0]);
        Swap(&num[0], &num[len]);    
        AdjustDown(num, 0, len);
        len--;
    }
    return 0;
}