选择排序（直接选择、堆排序）

直接选择排序 (不稳定)                       

 

排序过程：

     1 、首先在所有数据中经过 n-1次比较选出最小的数，把它与第 1个数据交换，

       2、然后在其余的数据内选出排序码最小的数，与第 2个数据交换...... 依次类推，直到所有数据排完为止。

         在第i 趟排序中选出最小关键字的数据，需要做 n-i次比较。

复杂度 ：

     总的比较次数为n(n-1)/2=O(n2)。

     当初始文件为正序时，移动次数为0；文件初态为反序时，每趟排序均要执行交换操作，总的移动次数取最大值3(n-1)。

     直接选择排序的平均时间复杂度为O(n2)，直接选择排序是不稳定的。

与冒泡排序的区别：

     1、选择排序 ：a[0]与a[1] 比较，如果 a[0]大于a[1], 记录最小数a[1]的位置1，然后j++，变成了a[2]与当前最小的数a[1]比较，慢慢往后循环，记录最小的数，最好将最小的数与第一个数a[0]交换位置  

     2、冒泡排序：首先第一个数 a[0]与第二个数a[1] 比较（从小到大），然后第二个数 a[1]与第三个数a[2] 比较;第三个数 a[2]与第四个数a[3]...... 第一内层循环结束； 

程序如下：

 

void SelectSort(int *arr,int num)
{
    if(NULL == arr)
        return;
    for(int i = 0;i <n-1){
        int k = i;
        for(int j = i+1;j < n;++j){
            if(arr[j] < arr[k])
                k = j;   //k记下目前找到的最小数的位置
        }
        if(k !=  i){
            int temp = arr[i];
            arr[i] = arr[k];
            arr[k] = temp;
        }
    }
}

堆排序（不稳定）                          

堆介绍：

      堆实际上是一棵完全二叉树，其任何一非叶节点满足性质：

           Key[i]<=key[2i+1]&&Key[i]<=key[2i+2]或者Key[i]>=Key[2i+1]&&key>=key[2i+2]，即任何一非叶节点的关键字不大于或者不小于其左右孩子节点的关键字。

      堆分为大顶堆和小顶堆，满足Key[i]>=Key[2i+1]&&key>=key[2i+2]称为大顶堆，满足Key[i]<=key[2i+1]&&Key[i]<=key[2i+2]称为小顶堆。由上述性质可知大顶堆的堆顶的关键字肯定是所有关键字中最大的，小顶堆的堆顶的关键字是所有关键字中最小的。

堆排序的思想：

       利用大顶堆(小顶堆)堆顶记录的是最大关键字(最小关键字)这一特性，使得每次从无序中选择最大记录(最小记录)变得简单。

      其基本思想为(大顶堆)：

           1)将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无序区；

              2)将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n]; 

              3)由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

      操作过程如下：

          1) 初始化堆：将R[1..n]构造为堆；

           2)调整这个堆，让它变成一个大顶堆；

           3)开始排序，将当前无序区的堆顶元素R[1]同该区间的最后一个记录交换，然后将新的无序区调整为新的堆。

       因此对于堆排序，最重要的两个操作就是构造初始堆和调整堆，其实构造初始堆事实上也是调整堆的过程，只不过构造初始堆是对所有的非叶节点都进行调整。

复杂度：

       堆排序的最坏时间复杂度为O(nlgn)。堆排序的平均性能较接近于最坏性能。

     由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。
     堆排序是就地排序，辅助空间为O(1)，它是不稳定的排序方法。

代码：

1. /*堆排序(大顶堆) 2011.9.14*/   
2.   
3. #include <iostream>  
4. #include<algorithm>  
5. using namespace std;  
6.   
7. void HeapAdjust(int *a,int i,int size)  //调整堆   
8. {  
9.     int lchild=2*i;       //i的左孩子节点序号   
10.     int rchild=2*i+1;     //i的右孩子节点序号   
11.     int max=i;            //临时变量   
12.     if(i<=size/2)          //如果i不是叶节点就不用进行调整   
13.     {  
14.         if(lchild<=size&&a[lchild]>a[max])  
15.         {  
16.             max=lchild;  
17.         }      
18.         if(rchild<=size&&a[rchild]>a[max])  
19.         {  
20.             max=rchild;  
21.         }  
22.         if(max!=i)  
23.         {  
24.             swap(a[i],a[max]);  
25.             HeapAdjust(a,max,size);    //避免调整之后以max为父节点的子树不是堆   
26.         }  
27.     }          
28. }  
29.   
30. void BuildHeap(int *a,int size)    //建立堆   
31. {  
32.     int i;  
33.     for(i=size/2;i>=1;i--)    //非叶节点最大序号值为size/2   
34.     {  
35.         HeapAdjust(a,i,size);      
36.     }      
37. }   
38.   
39. void HeapSort(int *a,int size)    //堆排序   
40. {  
41.     int i;  
42.     BuildHeap(a,size);  
43.     for(i=size;i>=1;i--)  
44.     {  
45.         //cout<<a[1]<<" ";  
46.         swap(a[1],a[i]);           //交换堆顶和最后一个元素，即每次将剩余元素中的最大者放到最后面   
47.           //BuildHeap(a,i-1);        //将余下元素重新建立为大顶堆   
48.           HeapAdjust(a,1,i-1);      //重新调整堆顶节点成为大顶堆  
49.     }  
50. }   
51.   
52. int main(int argc, char *argv[])  
53. {  
54.      //int a[]={0,16,20,3,11,17,8};  
55.     int a[100];  
56.     int size;  
57.     while(scanf("%d",&size)==1&&size>0)  
58.     {  
59.         int i;  
60.         for(i=1;i<=size;i++)  
61.             cin>>a[i];  
62.         HeapSort(a,size);  
63.         for(i=1;i<=size;i++)  
64.             cout<<a[i]<<" ";  
65.         cout<<endl;  
66.     }  
67.     return 0;  
68. }