数据结构：二叉树与堆的原理及 C 语言实现

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

typedef int HPDataType;
typedef struct Heap {
    HPDataType* arr;
    int size;
    int capacity;
}HP;

void HPInit(HP* php);
void HPPush(HP* php, HPDataType x);
void HPPop(HP* php);
void HPDestory(HP* php);
bool HPEmpty(HP* php);

3.2 初始化与扩容

初始化时分配内存并设置初始容量。插入元素时需检查容量，若不足则动态扩容，通常按 2 倍增长策略。

void HPInit(HP* php) {
    php->arr = NULL;
    php->capacity = php->size = 0;
}

void Swap(int* x, int* y) {
    int tmp = *x;
    *x = *y;
    *y = tmp;
}

void HPPush(HP* php, HPDataType x) {
    assert(php);
    if (php->size == php->capacity) {
        int newCapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
        HPDataType* tmp = (HPDataType*)realloc(php->arr, newCapacity * sizeof(HPDataType));
        if (tmp == NULL) {
            perror("realloc fail!");
            exit(1);
        }
        php->arr = tmp;
        php->capacity = newCapacity;
    }
    php->arr[php->size] = x;
    AdjustUp(php);
    ++php->size;
}

3.3 向上调整算法

插入新元素后，需从末尾开始向上比较，若小于父节点则交换，直到满足堆序性质。

void AdjustUp(HP* php) {
    int child = php->size - 1;
    int parent = (child - 1) / 2;
    while (child > 0) {
        if (php->arr[parent] > php->arr[child]) {
            Swap(&php->arr[parent], &php->arr[child]);
            child = parent;
            parent = (child - 1) / 2;
        } else {
            break;
        }
    }
}

3.4 向下调整算法

删除堆顶元素时，将最后一个元素移至堆顶，然后从根节点开始向下调整。每次选择左右孩子中较小的一个进行比较，若父节点较大则交换，直至满足堆序。

void AdjustDown(HP* php) {
    int parent = 0;
    int child = 2 * parent + 1;
    while (child < php->size) {
        if (child + 1 < php->size && php->arr[child] > php->arr[child + 1]) {
            child++;
        }
        if (php->arr[parent] > php->arr[child]) {
            Swap(&php->arr[parent], &php->arr[child]);
            parent = child;
            child = parent * 2 + 1;
        } else {
            break;
        }
    }
}

void HPPop(HP* php) {
    Swap(&php->arr[0], &php->arr[php->size - 1]);
    --php->size;
    AdjustDown(php);
}

void HPDestory(HP* php) {
    if (php->arr) free(php->arr);
    php->arr = NULL;
    php->size = php->capacity = 0;
}

bool HPEmpty(HP* php) {
    assert(php);
    return php->size == 0;
}

在实际运行中，注意边界条件判断，特别是空堆操作和单节点情况。堆的结构保证了插入和删除的时间复杂度均为 O(logN)，非常适合处理大规模数据的优先级管理问题。