選擇排序—簡單選擇排序（Simple Selection Sort）

基本思想：

在要排序的一組數中，選出最小（或者最大）的一個數與第1個位置的數交換；然後在剩下的數當中再找最小（或者最大）的與第2個位置的數交換，依次類推，直到第n-1個元素（倒數第二個數）和第n個元素（最後一個數）比較為止。

簡單選擇排序的示例：

操作方法：

第一趟，從n 個記錄中找出關鍵碼最小的記錄與第一個記錄交換；

第二趟，從第二個記錄開始的n-1 個記錄中再選出關鍵碼最小的記錄與第二個記錄交換；

以此類推.....

第i 趟，則從第i 個記錄開始的n-i+1 個記錄中選出關鍵碼最小的記錄與第i 個記錄交換，

直到整個序列按關鍵碼有序。

演算法實現：

1. void print(int a[], int n ,int i){  
2.     cout<<"第"<<i+1 <<"趟 : ";  
3.     for(int j= 0; j<8; j++){  
4.         cout<<a[j] <<"  ";  
5.     }  
6.     cout<<endl;  
7. }  
8. /** 
9.  * 陣列的最小值 
10.  * 
11.  * @return int 陣列的鍵值 
12.  */
13. int SelectMinKey(int a[], int n, int
     i)  
14. {  
15.     int k = i;  
16.     for(int j=i+1 ;j< n; ++j) {  
17.         if(a[k] > a[j]) k = j;  
18.     }  
19.     return k;  
20. }  
21. /** 
22.  * 選擇排序 
23.  * 
24.  */
25. void selectSort(int a[], int n){  
26.     int key, tmp;  
27.     for(int i = 0; i< n; ++i) {  
28.         key = SelectMinKey(a, n,i);           //選擇最小的元素
29.         if
    (key != i){  
30.             tmp = a[i];  a[i] = a[key]; a[key] = tmp; //最小元素與第i位置元素互換
31.         }  
32.         print(a,  n , i);  
33.     }  
34. }  
35. int main(){  
36.     int a[8] = {3,1,5,7,2,4,9,6};  
37.     cout<<"初始值：";  
38.     for(int j= 0; j<8; j++){  
39.         cout<<a[j] <<"  ";  
40.     }  
41.     cout<<endl<<endl;  
42.     selectSort(a, 8);  
43.     print(a,8,8);  
44. }  

 簡單選擇排序的改進——二元選擇排序

簡單選擇排序，每趟迴圈只能確定一個元素排序後的定位。我們可以考慮改進為每趟迴圈確定兩個元素（當前趟最大和最小記錄）的位置,從而減少排序所需的迴圈次數。改進後對n個數據進行排序，最多隻需進行[n/2]趟迴圈即可。具體實現如下：

1. void SelectSort(int r[],int n) {  
2.     int i ,j , min ,max, tmp;  
3.     for (i=1 ;i <= n/2;i++) {    
4.         // 做不超過n/2趟選擇排序 
5.         min = i; max = i ; //分別記錄最大和最小關鍵字記錄位置
6.         for (j= i+1; j<= n-i; j++) {  
7.             if (r[j] > r[max]) {   
8.                 max = j ; continue ;   
9.             }    
10.             if (r[j]< r[min]) {   
11.                 min = j ;   
12.             }     
13.       }    
14.       //該交換操作還可分情況討論以提高效率
15.       tmp = r[i-1]; r[i-1] = r[min]; r[min] = tmp;  
16.       tmp = r[n-i]; r[n-i] = r[max]; r[max] = tmp;   
17.     }   
18. }