数据结构——堆

一、堆的定义与基本操作

　　堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子结点的值。其中，如果父亲结点的值大于或等于孩子结点的值，那么称这样的堆为大顶堆，这时候每个结点的值都是以它为根结点的子树的最大值；如果父亲结点的值小于或等于孩子结点的值，那么称这样的堆为小顶堆，这时候每个结点的值都是以它为根结点的子树的最小值。

　　对完全二叉树来说，比较简洁的实现方法是使用数组来存储完全二叉树。这样结点按层序存储于数组中，其中第一个结点将存储在数组的 1 号位，并且数组 i 号位表示的结点的左孩子就是 2i 号位，而右孩子则是 (2i+1) 号位。于是定义如下：

#define maxn 100
// heap 为堆，n 为元素个数 
int heap[maxn], n=10; 

　　下面介绍向下调整方法：总是将当前结点 V 与它的左右孩子比较（如果有的话），假如孩子中存在权值比结点 V 的权值大的，就将其中权值最大的那个孩子结点与结点 V 交换；交换完毕后继续让结点 V 和孩子比较，直到结点 V 的孩子的权值都比结点 V 的权值小或是结点 V 不存在孩子结点。代码如下：

// 对 heap 数组在 [low,high] 范围进行向下调整
// 其中 low 为欲调整结点的数组下标，high 一般为最后一个元素的数组下标
void downAdjust(int low, int high) {
    int i=low, j=2*i;        // i 指向当前交换节点，j指向左孩子 
    while(j <= high) {
        // 若右孩子存在，且右孩子大于左子树 
        if(j+1 <= high && heap[j+1] > heap[j]) {
            j=j+1;            // 右孩子更大 
        }
        // 如果最大权值比欲调整结点大 
        if(heap[j] > heap[i]) {
            swap(&heap[j], &heap[i]);    // 交换 
            i = j;                        // 保持 i 指向欲调整结点，j 指向左孩子 
            j = 2*i;
        } else {
            break;                        // 孩子结点比根结点小，调整结束 
        }
    }
}

　　那个建堆的过程也就很容易了。假设序列中元素的个数为 n，数组下标在 $left [ 1,left lfloor frac{n}{2} ight floor ight ]$ 范围内的结点都是非叶子结点。于是可以从 $left lfloor frac{n}{2} ight floor$ 号开始倒着枚举结点，对每个遍历到的结点 i 进行 [i,n] 范围的调整。代码如下：

// 建堆
void createHeap() {
    int i;
    for(i=n/2; i>=1; --i) {                // 倒着枚举 
        downAdjust(i, n);                // 向下调整 
    }
}

　　

　　另外，如果要删除堆中的最大元素（也就是删除堆顶元素），并让其仍然保持堆的结构，那么只需要最后一个元素覆盖栈顶元素，然后对根结点进行调整即可。代码如下：

// 删除堆顶元素
void deleteTop() {
    heap[1] = heap[n--];                // 用最后一个元素覆盖栈顶元素，并让元素个数-1
    downAdjust(1, n);                    // 向下调整栈顶元素 
} 

　　那么，如果想要往堆里添加一个元素，可以把想要添加的元素放在数组最后，然后进行向下调整操作。向上调整总是把欲调整结点与父亲结点比较，如果权值比父亲结点大，那么就交换其与父亲结点，这样反复比较，直到到达堆顶或是父亲结点的权值较大为止。代码如下：

// 对 heap 数组在 [low,high] 范围进行向上调整
// 其中 low 为欲调整结点的数组下标，high 一般为最后一个元素的数组下标
void upAdjust(int low, int high) {
    int i=high, j=i/2;                     // i 为欲调整结点，j 为其父亲
    while(j >= low) {
        // 如果父亲结点小于欲调整结点 
        if(heap[j] < heap[i]) {
            swap(&heap[j], &heap[i]);    // 交换 
            i = j;                        // 保持 i 指向欲调整结点，j 指向父亲结点 
            j = i/2;
        } else {
            break;                        // 孩子结点比根结点小，调整结束 
        }
    } 
}

　　在此基础上就很容易实现添加元素的代码了：

// 添加元素 x
void insert(int x) {
    heap[++n] = x;                        // 让元素个数+1，然后将数组末位赋值为 x
    upAdjust(1, n);                     // 向上调整插入的结点 
} 

二、堆排序

　　堆排序是指使用堆结构对一个序列进行排序。此处讨论递增排序的情况。

　　可以倒着遍历数组，假设当前遍历到 i 号位，那么堆顶元素与 i 号位的元素交换，接着在 [1,i-1] 范围内对栈顶元素进行一次向下调整即可。代码如下：

// 堆排序
void heapSort() {
    int i;
    for(i=n; i>1; --i) {                // 倒着枚举 
        swap(&heap[i], &heap[1]);        // 交换 heap[i] 与堆顶
        downAdjust(1, i-1);                // 调整堆顶 
    }
}

　　完整测试代码如下：

/*
    堆 
*/

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>

#define maxn 100
// heap 为堆，n 为元素个数 
int heap[maxn], n=10; 

// 交换 a,b
void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
} 

// 对 heap 数组在 [low,high] 范围进行向下调整
// 其中 low 为欲调整结点的数组下标，high 一般为最后一个元素的数组下标
void downAdjust(int low, int high) {
    int i=low, j=2*i;        // i 指向当前交换节点，j指向左孩子 
    while(j <= high) {
        // 若右孩子存在，且右孩子大于左子树 
        if(j+1 <= high && heap[j+1] > heap[j]) {
            j=j+1;            // 右孩子更大 
        }
        // 如果最大权值比欲调整结点大 
        if(heap[j] > heap[i]) {
            swap(&heap[j], &heap[i]);    // 交换 
            i = j;                        // 保持 i 指向欲调整结点，j 指向左孩子 
            j = 2*i;
        } else {
            break;                        // 孩子结点比根结点小，调整结束 
        }
    }
} 

// 建堆
void createHeap() {
    int i;
    for(i=n/2; i>=1; --i) {                // 倒着枚举 
        downAdjust(i, n);                // 向下调整 
    }
} 

// 删除堆顶元素
void deleteTop() {
    heap[1] = heap[n--];                // 用最后一个元素覆盖栈顶元素，并让元素个数-1
    downAdjust(1, n);                    // 向下调整栈顶元素 
} 

// 对 heap 数组在 [low,high] 范围进行向上调整
// 其中 low 为欲调整结点的数组下标，high 一般为最后一个元素的数组下标
void upAdjust(int low, int high) {
    int i=high, j=i/2;                     // i 为欲调整结点，j 为其父亲
    while(j >= low) {
        // 如果父亲结点小于欲调整结点 
        if(heap[j] < heap[i]) {
            swap(&heap[j], &heap[i]);    // 交换 
            i = j;                        // 保持 i 指向欲调整结点，j 指向父亲结点 
            j = i/2;
        } else {
            break;                        // 孩子结点比根结点小，调整结束 
        }
    } 
}

// 添加元素 x
void insert(int x) {
    heap[++n] = x;                        // 让元素个数+1，然后将数组末位赋值为 x
    upAdjust(1, n);                     // 向上调整插入的结点 
} 

// 堆排序
void heapSort() {
    int i;
    for(i=n; i>1; --i) {                // 倒着枚举 
        swap(&heap[i], &heap[1]);        // 交换 heap[i] 与堆顶
        downAdjust(1, i-1);                // 调整堆顶 
    }
}

// 输出堆 
void print() {
    int i; 
    for(i=1; i<=n; ++i) {                
        printf("%d ", heap[i]);
    }
    printf("
");    
} 

int main() {
    int i;
    for(i=1; i<=n; ++i) {
        scanf("%d", &heap[i]);
    } 
    createHeap();                        // 建堆 
    print();                            // 输出堆 
    deleteTop();                        // 删除栈顶元素 
    print();                            // 输出堆 
    insert(99);                            // 插入99
    print();                            // 输出堆 
    heapSort();                            // 堆排序
    print();                            // 输出排序结果 

    return 0;
}