数据结构和算法分析之排序算法--选择排序（堆排序）

选择排序–堆排序

堆排序是一种树形选择的排序，是对直接选择排序的有效改进。
（直接选择排序：第一次选择最小值，与第一位数交换，再从后面选择最小的，和第二位数交换……直至排序结束，共n-1次）

基本思想：
堆的定义如下：具有n个元素的序列（k1,k2,…,kn），当且仅当满足：

时称之为堆。由堆的定义可以看出，堆顶元素（第一个元素）必须为最小项（或最大项）。
若一一维数组存储一个堆，则堆对应一颗完全二叉树，且所有非叶结点的值均不大于（不小于）其子女的值，根结点（堆顶元素）的值是最小（或最大的）。如下：
（a）大顶堆序列：（96, 83,27,38,11,09)
（b）小顶堆序列：（12，36，24，85，47，30，53，91）

初始时把要排序的n个数的序列看作是一颗顺序存储的二叉树，调整他们的存储序列，使之成为一个堆，将堆顶元素输出，得到n个元素中最小（或者最大）的元素，这时堆的根结点的数最小（或者最大）。然后对后面（n-1）个元素重新调整使之成为堆，再次输出堆顶元素。依次类推，直到只有两个结点的堆，并对它们做比较，最后输出n个结点的有序序列。上述过程称之为堆排序。
因此，实现堆排序需要解决两个问题：
1、如何将n个待排序的数建成堆；
2、输出堆顶元素后，怎么调整剩余的n-1个元素，使之成为新堆；

下面就针对这两个问题进行讨论：
首先讨论第二个问题：输出堆顶元素后，对剩余n-1元素重新建成堆的调整过程。
1）设有m个元素的堆，输出堆顶元素后，剩下m-1个元素。将堆底元素送入堆顶（最后一个元素与堆顶进行交换），此时堆被破坏（根结点不满足堆的性质）。
2）将根结点与左右子树中较小的元素进行交换。
3）若与左子树交换：如果左子树堆被破坏，即左子树的堆被破坏，即左子树的根结点不满足堆的性质，重复方法（2）；
4）若与右子树交换，如果右子树堆被破坏，即右子树的根结单不满足堆的性质。重复方法（2）；
5）继续对不满足堆性质的子树进行上述交换操作，直至堆被建成。
称这个自根结点到叶子结点的调整过程为筛选，如下图：

再讨论对n个元素初始建堆的过程。
建堆方法：堆初始序列建堆的过程，就是一个反复筛选的过程。
1）n个结点的完全二叉树，则最后一个结点是第[n/2]个结点的子树。
2）筛选从第[n/2]个结点为根的子树开始，该子树成为堆。
3）之后向前依次对各节点为根的子树进行筛选，使之成为堆，直到根结点。

如图建堆初始过程：无序序列：（49，38，65，97，76，13，27，49）

算法的实现：
从算法描述来看，堆排序需要两个过程，一是建立堆，而是堆顶与堆的最后一个元素交换位置的筛选过程。所以堆排序两个函数组成。
1）建堆的渗透函数；
2）反复调用渗透函数实现排序的函数；

代码如下：

#include
using namespace std;

void print(int a[], int n){  
    for(int j= 0; j"  ";  
    }  
    cout</** 
 * 已知H[s…m]除了H[s] 外均满足堆的定义 
 * 调整H[s],使其成为大顶堆.即将对第s个结点为根的子树筛选,  
 * 
 * @param H是待调整的堆数组 
 * @param s是待调整的数组元素的位置 
 * @param length是数组的长度 
 * 
 */  
//筛选的过程就是把序列变成堆序列--大顶堆或小顶堆
void HeapAdjust(int H[],int s, int length)  
{  
    int tmp  = H[s];  
    int child = 2*s+1; //左孩子结点的位置。(i+1 为当前调整结点的右孩子结点的位置)  
    while (child < length) {  
        if(child+1 1]) { // 如果右孩子大于左孩子(找到比当前待调整结点大的孩子结点)  
            ++child ;  //比较左右子孩子哪个较大，取大的值。
        }  
        if(H[s]// 如果较大的子结点大于父结点  --结点取较大的值
            H[s] = H[child]; // 那么把较大的子结点往上移动，替换它的父结点  
            s = child;       // 重新设置s ,即待调整的下一个结点的位置  
            child = 2*s+1;  
        }  else {            // 如果当前待调整结点大于它的左右孩子，则不需要调整，直接退出  
             break;  
        }  
        H[s] = tmp;         // 当前待调整的结点放到比其大的孩子结点位置上  
    }  
    print(H,length);  
}  


/** 
 * 初始堆进行调整 
 * 将H[0..length-1]建成堆 
 * 调整完之后第一个元素是序列的最小的元素 
 */  
void BuildingHeap(int H[], int length)  
{   
    //最后一个有孩子的节点的位置 i=  (length -1) / 2  
    //从最后一个结点开始筛选，筛选个数是树的一半
    for (int i = (length -1) / 2 ; i >= 0; --i)  
        HeapAdjust(H,i,length);  
}  
/** 
 * 堆排序算法 
 互换元素
 */  
void HeapSort(int H[],int length)  
{  
    //初始堆  
    BuildingHeap(H, length);  
    //从最后一个元素开始对序列进行调整  
    for (int i = length - 1; i > 0; --i)  
    {  
        //交换堆顶元素H[0]和堆中最后一个元素  
        int temp = H[i]; H[i] = H[0]; H[0] = temp;  
        //每次交换堆顶元素和堆中最后一个元素之后，都要对堆进行调整  
        HeapAdjust(H,0,i);  
  }  
}   
int main(){  
    int H[10] = {3,1,5,7,2,4,9,6,10,8};  
    cout<<"初始值：";  
    print(H,10);  
    HeapSort(H,10);  
    //selectSort(a, 8);  
    cout<<"结果：";  
    print(H,10);  

    system("pause");
    return 0;

}  

效率分析–堆排序

堆排序的时间复杂度，主要在初始化堆过程和每次选取最大数后重新建堆的过程。
1、初始化建堆过程时间：O（n）;
推算过程，参考链接：http://blog.csdn.net/yuzhihui_no1/article/details/44258297
2、更改堆元素后重建堆时间：O（nlogn）
推算过程：
重建堆的过程需要循环n-1次，每次都是从根节点往下循环查找，所以每一次时间是logn，总时间为：logn(n-1)=nlogn-logn;

综上所述，时间复杂度为：O（nlogn）。

---

本文资料和代码参照：http://blog.csdn.net/hguisu/article/details/7776068/
特别鸣谢~