八大排序算法（4） 堆排序

基本思想

是对简单选择排序的改进，是一种树形结构的排序。
利用堆的特性，快速选择出序列中的最大最小元素。

堆的定义：

用树表示更加直观：

即：父节点 不大于/不小于 其子节点的完全二叉树。
降序时称为 大堆顶，升序时称为 小堆顶。

这样的堆，其堆顶就是整个序列中最大/最小的元素。
不断的取出堆顶、将剩下序列重组成堆的过程就叫堆排序。

树采用顺序存储：{96,83,27,38,11,09}， {12,36,24,85,47,30,53,91}
序列是树的顺序存储，因此 节点、父、子 在序列中的位置为 i，2i，2i+1， 反映到序列中的 index 为 i - 1, 2*i-1, 2*i。

重点

 1. 初始化时将整个序列转换成堆  
 2. 取出堆顶后，将剩下的元素快速组成堆

先说第二点的算法思路：

 1. 取出堆顶后 i 后，将堆底元素取出补为堆顶
 2. 检查到堆被破坏，将 堆顶 与其子节点中小的元素交换
 3. 对交换后的子树重复2

示例图：

再说第一点的算法思路：

 1. 假设 长度 n 的 序列 k 为堆
 2. 最后一个节点是 节点 n/2 的子节点，那么从 n/2 开始向上筛选
 3. 从 父子节点 中选举最小的为 父节点
 4. 对交换后的子节点 重复 3，直到叶子节点
 5. 检查下一个 n/2 - 1 ，重复 3， 直到 0

示例图：

代码：

void printList(int *l, int n) {
    for (int i = 0; i < n; i++) {
        printf("%d ", l[i]);
    }
    printf("\n");
}

/*
 * 修复堆
 * 
 * 从 父子 节点中选举最小的为父节点。
 * 如果最小的不是父节点的话，那么交换过的子节点也需要检查。
 */
void adjustHeap(int *l, int n, int topIndex, int adjustIndex) {
    // 要检查的元素 index
    int minIndex = adjustIndex;
    // 堆顶不为 0 时，计算 adjustIndex 的子节点 index 要考虑到偏移
    int lcIndex = 2 * (adjustIndex - topIndex + 1) - 1 + topIndex;
    int rcIndex = 2 * (adjustIndex - topIndex + 1) + topIndex;

    // 跟 左子节点比较，替换 小的 index
    if (lcIndex < n && l[minIndex] > l[lcIndex] ){
        minIndex = lcIndex;
    }
    // 跟 右子节点比较，替换 小的 index
    if (rcIndex < n && l[minIndex] > l[rcIndex]){
        minIndex = rcIndex;
    }
    // 如果小的index 不是 堆顶的话，那么换顶，然后检查子堆
    if ( minIndex != adjustIndex ){
        int k = l[minIndex];
        l[minIndex] = l[adjustIndex];
        l[adjustIndex] = k;
        // 子堆 minIndex 换了 堆顶，要检查一下
        adjustHeap(l, n, topIndex, minIndex);
    }
}

/*
 * 创建堆
 * 
 * 1、假设 长度 n 的 序列 k 为堆
 * 2、最后一个节点为 n / 2 的子节点，从 n / 2 开始向上筛选
 * 3、从 父子节点中选举最小的为 父节点
 * 4、检查下一个 n / 2 - 1 ，重复 3， 直到 0
 */
void buildHeap(int *l, int n) {
    for (int i = n / 2; i > 0;i-- ) {
        // 节点 i 对应的 index 是 i - 1, 子节点 index  2 * i - 1、 2 * i
        int min = i - 1;
        int lc = 2 * i - 1;
        int rc = 2 * i;

        //　选举最小的为 堆顶
        if (l[i - 1] > l[lc]){
            min = lc;
        }
        if ( 2*i < n && l[min] > l[rc]){
            min = rc;
        }

        if ( min != i-1 ) {
            int k = l[i - 1];
            l[i - 1] = l[min];
            l[min] = k;
            // 子堆 min 换了堆顶，要检查堆 min
            adjustHeap(l, n, 0, min);
        }
    }
}


int main() {
    int list[50] = { 10, 7, 1 , 8, 5, 12, 6, 3, 9 };
    int n = 9;
    printList(list, n);

    // 创建小堆顶
    buildHeap(list, n);
    printList(list, n);

    printf("======\n");

    // 建好堆后，初始堆顶就是最小的
    for (int i = n - 1; i > 0; i--) {
        //将堆顶换到堆底.  这是小堆顶，每次都将最小的元素换到堆底，然后 堆缩小 1，最后得出降序
        int exchange = list[0];
        list[0] = list[i];
        list[i] = exchange;
        // 堆 0 被破坏，执行检查
        adjustHeap(list, i, 0, 0);
        printList(list, n);
    }


    system("pause");
    return 0;
}

以上

原文链接 http://blog.csdn.net/u011546766/article/details/74045324