排序算法-選擇排序

選擇排序

　流程：

　　遍歷整個數組找到最小的數，和索引爲0的元素交換位置

　　再次遍歷數組，找到第二小的元素和索引爲1的元素交換位置

　　遍歷 length-1 次...

　　(只有第一次是遍歷整個數組，選擇排序完成了的元素就不用在遍歷了)

　　時間複雜度：O(n^2)

　　代碼實現(java)：

    public static void main(String[] args) {
        int[] arrs = {5, 20, 100, 50, 1, 40, 2};
        chooseSort(arrs);
    }
    
    private static void chooseSort(int[] arrs) {
        //遍歷次數 length-1 次便可(固然遍歷length也不會出現報錯，最大程度追求效率)
        for(int i = 0;i < arrs.length - 1;i++){
            int index = i;
            //遍歷找最小的元素
            for(int j = i;j < arrs.length;j++){
                if(arrs[j] < arrs[index]){
                    index = j;
                }
            }
            //若是這次遍歷獲得的最小元素不是當前最小索引位置的元素 則交換位置
            if(arrs[index] != arrs[i]){
                repalceIndex(arrs, index, i);
            }
        }
        for (int i : arrs) {
            System.out.println(i);
        }
    }

    //交換元素位置的方法
    private static void repalceIndex(int[] arrs, int small, int i) {
        int temp = arrs[small];
        arrs[small] = arrs[i];
        arrs[i] = temp;
    }

在選擇排序的基礎上衍生出或者說是一種優化效率的選擇排序：雙向選擇排序

雙向選擇排序

　流程:

　　遍歷整個數組找到最小的數min，最大的數max，最小的數和索引爲0的元素交換位置，最大的數和索引爲length - 1的元素交換位置

　　再次遍歷數組，最小的數min，最大的數max，最小的數和索引爲1的元素交換位置，最大的數和索引爲length - 2的元素交換位置

　　遍歷 length/2 次...

　　好處是減小了遍歷了次數，遍歷次數大約減小一半。

　　時間複雜度：O(n^2/2) 

　　代碼實現(java):

 1     public static void main(String[] args) {
 2         int[] arrs = {5, 20, 100, 50, 1, 40, 2, 0};
 3         chooseSort2(arrs);
 4     }
 5 
 6     /**
 7      * 雙向選擇排序
 8      * @param arrs
 9      */
10     private static void chooseSort2(int[] arrs) {
11         //遍歷次數
12         for(int i = 0;i < arrs.length / 2 ;i++){
13             //本次遍歷的最小和最大索引
14             int small = i;
15             int big = arrs.length - 1 - i;
16             for(int j = i;j < arrs.length - i;j++){
17                 if(arrs[j] < arrs[small]){
18                     small = j;
19                 }
20                 if(arrs[j] > arrs[big]){
21                     big = j;
22                 }
23             }
24             //若是這次遍歷獲得的最小元素不是當前最小索引位置的元素 則交換位置
25             if(arrs[small] != arrs[i]){
26                 repalceIndex(arrs, small, i);
27             }
28             //若是這次遍歷獲得的最大元素不是當前最大索引位置的元素 則交換位置
29             if(arrs[big] != arrs[arrs.length - 1 - i]){
30                 repalceIndex(arrs, big, arrs.length - 1 - i);
31             }
32         }
33         for (int i : arrs) {
34             System.out.println(i);
35         }
36     }
37     
38     //交換元素位置的方法
39     private static void repalceIndex(int[] arrs, int small, int i) {
40         int temp = arrs[small];
41         arrs[small] = arrs[i];
42         arrs[i] = temp;
43     }

以上爲本身編譯經過的代碼以及結合部分書籍得出來的結論，若有不對還望指出！