排序系列算法——堆排序

堆：大根堆与小根堆

      堆排序是建立在堆基础上的排序方法，首先了解一下什么是堆。

      常用的堆一般有两种，大根堆和小根堆。堆可以看做是一棵二叉树，其父节点的值总是大于（大根堆）或者小于（小根堆）子节点的值。举一个例子：

 

         　　　　　　　　　　　　　　　　图1 不满足堆的条件                 图2大根堆                             图3 小根堆

      图1不是堆，因为不满足父节点的值大于或者小于子节点的值；

      图2是大根堆，根节点是最大值，父节点都大于或等于子节点的值；

      图3是小根堆，根节点是最小值，父节点都小于或等于子节点的值。

堆排序

      下面以大根堆为例讲解堆排序：

      大根堆有一个很好的性质，根节点的数值总是大于其他所有节点的数值，利用这个性质，可以实现排序的工作。堆排序的步骤可以描述如下：

      1.构建大根堆。首先我们的原始数组一般情况下是不满足堆的条件，既然我们要可用大根段的性质进行排序，第一步当然是对原始数组进行处理，构建大根堆。

      2.根节点数据处理以及大根堆重构。构建了大根堆之后，根节点的数据是最大值，将该数值取出，对剩下的元素重构大根堆，这时根节点是剩下元素的最大值，取出。只要不断重复上述的操作，不断取出未排序元素的最大值，直到未排序的元素只剩一个，就完成了排序工作。

      说得有点抽象，直接用一个实际的例子说明堆排序的工作步骤：

      对一个无序的序列A={5,4,17,13,15,12,10 }按从小到大进行排序，序列的下标分别为{1,2,3,4,5,6,7}，A[i]表示下标为i的元素。

      第一步：对无序的数组构造大根堆

 

大根堆的根节点是整个序列的最大值。

       第二步：

       将A[1]与A[7]互换，此时A[7]为序列的最大值，A[7]已经排序完毕，剩余的元素A[1]~A[6]形成新的未排序序列，由于此时序列不是大根堆，需要重构大根堆。

       第三步：

       将A[1]与A[6]互换，此时A[6]为序列的最大值，A[6]已经排序完毕，剩余的元素A[1]~A[5]形成新的未排序序列，由于此时序列不是大根堆，需要重构大根堆。

      第四步：

      将A[1]与A[5]互换，此时A[5]为序列的最大值，A[5]已经排序完毕，剩余的元素A[1]~A[4]形成新的未排序序列，由于此时序列不是大根堆，需要重构大根堆。

      第五步：

      将A[1]与A[4]互换，此时A[4]为序列的最大值，A[4]已经排序完毕，剩余的元素A[1]~A[3]形成新的未排序序列，由于此时序列不是大根堆，需要重构大根堆。

      第六步：

      将A[1]与A[3]互换，此时A[3]为序列的最大值，A[3]已经排序完毕，由于此时未排序的序列只剩下两个元素，而且A[0]>A[1]，将A[0]与A[1]互换即可得到最终的已排序序列。

 

C++程序实现

从上述的排序过程可知，堆排序主要有两个过程，大根堆的构建与重构：

1、大根堆的重构

　　如何实现大根堆的重构？如果一个原有的数组满足大根堆的性质，而只有其中一个元素改变从而破坏了大根堆的性质，那么可以从该元素出发，不断”逐级下降“，让子节点小于等于父子节点，满足大根堆的性质。以一个实例说明重构的过程：

　　堆排序的过程中，每一次改变的只有根节点的元素，因此只需要从根节点出发，进行如上图的操作即可实现大根堆的重构。C++代码如下：

void ReBuildMaxHeap(int *array,int arraylength,int startIndex){
    int index=0;
    //int j=0;
    int max=0;
    while((2*startIndex+1)<arraylength){
        index = startIndex;
        max = array[index];
        if(max<(array[2*startIndex+1])){
            max=array[2*startIndex+1];
            index=2*startIndex+1;
        }
        if(2*startIndex+2<arraylength&&max<array[2*startIndex+2]){
            max=array[2*startIndex+2];
            index=2*startIndex+2;
        }
        if(index==startIndex){
            break;
        }
        swap(array,index,startIndex);
        startIndex = index;
    }
}

1、  构建大根堆。

　　要构建大根堆，只需要遍历所有非叶子节点元素，使其所有的叶子节点均不大于足该节点元素即可。构建大根堆自低向上对数组进行遍历，如果发现父节点的值小于子节点的值，则将父节点的值与子节点的最大值进行交换，保证父节点的数据总是大于子节点的数据。如果发生了数据的交换，有可能令子节点不满足大根堆条件，需要进行会输重构大根堆。以一个实际的例子说明构建大根堆的过程：

C++代码如下：

void createHeap(int *array,int length){
    int max=0;
    int index=0;
    for(int i=floor(length/2)-1;i>=0;i--){
        index = i;
        max = array[i];
        if(max<array[2*i+1]){
            index=2*i+1;
            max = array[2*i+1];
        }
        if(2*i+2<length&&max<array[2*i+2]){
            index = 2*i+2;
            max = array[2*i+2];
        }
        if(index!=i){
            swap(array,index,i);
            ReBuildMaxValue(array,length,index);
        }
    }
}

全部源代码：

#include "stdafx.h"
#include <iostream>
using namespace std;

//两个文位置的数据交换
void swap(int *array,int num1,int num2){
    int temp = *(array+num1);
    *(array+num1) = *(array+num2);
    *(array+num2) = temp;
}

//重构大根堆
void ReBuildMaxValue(int *array,int arraylength,int startIndex){
    int index=0;
    //int j=0;
    int max=0;
    while((2*startIndex+1)<arraylength){
        index = startIndex;
        max = array[index];
        if(max<(array[2*startIndex+1])){
            max=array[2*startIndex+1];
            index=2*startIndex+1;
        }
        if(2*startIndex+2<arraylength&&max<array[2*startIndex+2]){
            max=array[2*startIndex+2];
            index=2*startIndex+2;
        }
        if(index==startIndex){
            break;
        }
        swap(array,index,startIndex);
        startIndex = index;
    }
}

//构建大根堆
void createHeap(int *array,int length){
    int max=0;
    int index=0;
    for(int i=floor(length/2)-1;i>=0;i--){
        index = i;
        max = array[i];
        if(max<array[2*i+1]){
            index=2*i+1;
            max = array[2*i+1];
        }
        if(2*i+2<length&&max<array[2*i+2]){
            index = 2*i+2;
            max = array[2*i+2];
        }
        if(index!=i){
            swap(array,index,i);
            ReBuildMaxValue(array,length,index);
        }
    }
}

//堆排序
void heapSort(int *array,int arraylength){
    createHeap(array,10);
    for(int i=arraylength-1;i>0;i--){
        swap(array,i,0);
        ReBuildMaxValue(array,i,0);
    }
}

int main(int argc, _TCHAR* argv[])
{
    int values[10]={5,4,17,13,15,12,10,7,11,9};
    heapSort(values,10);
    for(int i=0;i<10;i++){
        cout<<*(values+i)<<endl;
    }
    return 0;
}