【排序算法】选择排序(C++实现)

选择排序算法就是每一趟从待排序的记录中选出关键字最小（最大）的记录，顺序放在已排好序的子文件的最后（最前），直到全部记录排序完毕。常见的选择排序有直接选择排序（Selection Sort），堆排序（Heap Sort），平滑排序（Smooth Sort），笛卡尔树排序（Cartesian Sort），锦标赛排序（Tournament Sort），循环排序（Cycle）。下面介绍前两种：

（一）直接选择排序

最差时间复杂度：O(n^2)
最优时间复杂度：O(n^2)
平均时间复杂度：O(n^2)
稳定性：不稳定

直接选择排序（Selection Sort），这是一种简单直观的排序算法。它首先在未排序序列中找到最小（大）元素，存放到排序序列的其起始位置，然后再从剩余未排序的序列元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素排序完毕。

算法示意图：

实现代码：

[cpp] view plaincopy

1. void SelectSort(int *a, int len)  
2. {  
3.     for (int i=0; i<len-1; i++)  
4.     {  
5.         int k = i;  
6.         int key = a[i];  
7.         for (int j=i+1; j<len; j++)  
8.         {  
9.             if (a[j]<key)  
10.             {  
11.                 k = j;  
12.                 key = a[j];  
13.             }  
14.         }  
15.         if (k!=i)  
16.             swap(a[i], a[k]);  
17.     }  
18. }  

（二）堆排序

最差时间复杂度：O(nlogn)
最优时间复杂度：O(nlogn)
平均时间复杂度：O(nlogn)
稳定性：不稳定

堆排序（Heap Sort），是利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。

通常堆是通过一维数组来实现的，在起始数组为0的情形中，对于节点i：
其左子节点的下标为 (2*i+1)；
其右子节点的下标为 (2*i+2)；
其父节点的下标为 floor((i-1)/2)。
在堆的数据结构中，堆中的最大值总是位于根节点。堆中定义一下三个操作：
1.最大堆调整（Max Heapify）：在假定节点i的左右子节点为根的两颗二叉树都是最大堆的前提下，确保父节点大于子节点，否则下降原父节点，最终使以i为根的子树成为最大堆。
2.创建最大堆（Build Max Heap）：将堆所有数据重新排序，对所有非叶子节点调用一次Max Heapify。

3.堆排序（Heap Sort）：首先创建最大堆，然后依次将堆的根节点与末节点交换、剔除末节点、对根节点进行最大堆调整，直到堆中的节点数为1，排序结束。

算法示意图：

实现代码：

[cpp] view plaincopy

1. // 最大堆调整  
2. void MaxHeapify(int *a, int i, int heapSize)  
3. {  
4.     int l = (i+1)*2-1;  
5.     int r = (i+1)*2;  
6.     int largest;  
7.   
8.     if (l<=heapSize && a[l]>a[i])  
9.         largest = l;  
10.     else  
11.         largest = i;  
12.   
13.     if (r<=heapSize && a[r]>a[largest])  
14.         largest = r;  
15.   
16.     if (largest!=i)  
17.     {  
18.         swap(a[i], a[largest]);  
19.         MaxHeapify(a, largest, heapSize);  
20.     }  
21. }  
22.   
23. // 创建最大堆  
24. void BuildMaxHeap(int *a, int len)  
25. {  
26.     for (int i=len/2-1; i>=0; i--)  
27.     {  
28.         MaxHeapify(a, i, len-1);  
29.     }  
30. }  
31.   
32. // 堆排序  
33. void HeapSort(int *a, int len)  
34. {  
35.     BuildMaxHeap(a, len);  
36.     for (int i=len-1; i>0; i--)  
37.     {  
38.         swap(a[0], a[i]);  
39.         MaxHeapify(a, 0, i-1);  
40.     }  
41. }