数据结构：二叉树与堆

2.2.2 完全二叉树

完全二叉树和满二叉树又不同，完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为 K 的，有 n 个结点的二叉树，当且仅当其每一个结点都与深度为 K 的满二叉树中编号从 1 至 n 的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。

2.3 二叉树存储结构

2.3.1 顺序结构

无非就创建一个数组，挨个存二叉树的数据，根节点无疑是 0，然后他的两个孩子节点就是 1 和 2,1 的两个孩子节点就是 4 和 5，以此类推。

2.3.2 链式结构

链式结构更容易想象到，就是每个节点有两个指向，一个指向左孩子，一个指向右孩子，然后每个节点都存储数据。

3. 实现顺序结构二叉树

顺序结构实现二叉树一般使用堆的方式，

堆又分为大堆和小堆

• 小堆：根节点是最小的数据，每个节点都比他的父节点大
• 大堆：和小堆刚相反，根节点最大，每个节点都比父节点小

并且堆是一种完全二叉树

3.1 堆的实现

头文件 Heap.h

#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);

Heap.c

#include"Heap.h"

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

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

void AdjustUp(HP* php) {
    int child = php->size - 1;
    int parent = (php->size - 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;
        }
    }
}

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;
}

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);
}

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

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

3.2 向下调整算法

就是在删除堆顶的时候，将堆顶与最后一个元素进行交换，然后 php->size--,从根节点挨个开始比较下一个节点的大小。