Java（.NET）经典排序算法之选择排序

一、算法原理

对比数组中前一个元素跟后一个元素的大小，如果后面的元素比前面的元素小则用一个变量k来记住他的位置，

接着第二次比较，前面“后一个元素”现变成了“前一个元素”，继续跟他的“后一个元素”进行比较如果后面的元素比

他要 小则用变量k记住它在数组中的位置(下标)，等到循环结束的时候，我们应该找到了最小的那个数的下标了，

然后进行 判断，如果这个元素的下标不是第一个元素的下标，就让第一个元素跟他交换一下值， 这样就找到整

个数组中最小的 数了。然后找到数组中第二小的数，让他跟数组中第二个元素交换一下值，以此类推。

二、算法分析

1.时间复杂度

选择排序的交换操作介于 0 和 (n - 1） 次之间。选择排序的比较操作为 n (n - 1） / 2 次之间。选择排序的赋值操作介于 0 和 3 (n - 1） 次之间。

比较次数O(n^2），比较次数与关键字的初始状态无关，总的比较次数N=(n-1）+(n-2）+...+1=n*(n-1）/2。交换次数O(n），最好情况是，已经有序，交换0次；最坏情况交换n-1次，逆序交换n/2次。交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CPU时间多，n值较小时，选择排序比冒泡排序快。

2.稳定性

选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果一个元素比当前元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。比较拗口，举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中两个5的相对前后顺序就被破坏了，所以选择排序是一个不稳定的排序算法。

三 、算法演示

四、代码实现

[java]  view plain  copy

1. public class SelectSort {  
2.     public static void selectSort(int[] a) {  
3.         int minIndex = 0;  
4.         int temp = 0;  
5.         if ((a == null) || (a.length == 0))  
6.             return;  
7.         for (int i = 0; i < a.length - 1; i++) {  
8.             minIndex = i;// 无序区的最小数据数组下标  
9.             for (int j = i + 1; j < a.length; j++) {  
10.                 // 在无序区中找到最小数据并保存其数组下标  
11.                 if (a[j] < a[minIndex]) {  
12.                     minIndex = j;  
13.                 }  
14.             }  
15.             if (minIndex != i) {  
16.                 // 如果不是无序区的最小值位置不是默认的第一个数据，则交换之。  
17.                 temp = a[i];  
18.                 a[i] = a[minIndex];  
19.                 a[minIndex] = temp;  
20.             }  
21.             System.out.println("第" + (i + 1) + "趟：");  
22.             printArray(a);  
23.         }  
24.     }  
25.   
26.     private static void printArray(int[] source) {  
27.         for (int i = 0; i < source.length; i++) {  
28.             System.out.print("\t" + source[i]);  
29.         }  
30.         System.out.println();  
31.     }  
32.   
33.     public static void main(String[] args) {  
34.         int[] source = { 70,30,40,10,80,20,90,100,75,60,45};  
35.         System.out.println("初始关键字：");  
36.         printArray(source);  
37.   
38.         selectSort(source);  
39.   
40.         System.out.println("\n\n排序后：");  
41.         printArray(source);  
42.     }  
43. }  

五、运行结果

[java]  view plain  copy

1. 初始关键字：  
2.     70  30  40  10  80  20  90  100 75  60  45  
3. 第1趟：  
4.     10  30  40  70  80  20  90  100 75  60  45  
5. 第2趟：  
6.     10  20  40  70  80  30  90  100 75  60  45  
7. 第3趟：  
8.     10  20  30  70  80  40  90  100 75  60  45  
9. 第4趟：  
10.     10  20  30  40  80  70  90  100 75  60  45  
11. 第5趟：  
12.     10  20  30  40  45  70  90  100 75  60  80  
13. 第6趟：  
14.     10  20  30  40  45  60  90  100 75  70  80  
15. 第7趟：  
16.     10  20  30  40  45  60  70  100 75  90  80  
17. 第8趟：  
18.     10  20  30  40  45  60  70  75  100 90  80  
19. 第9趟：  
20.     10  20  30  40  45  60  70  75  80  90  100  
21. 第10趟：  
22.     10  20  30  40  45  60  70  75  80  90  100  
23.   
24.   
25. 排序后：  
26.     10  20  30  40  45  60  70  75  80  90  100  

转自：  http://blog.csdn.net/ouyang_peng/article/details/46546137