三分鍾徹底理解選擇排序

1.原理：每次從待排序的數據元素中選出最小(或者最大)的一個元素，存放在已排好序列的起始位置(或者末尾位置)，直到全部待排序的數據元素排完。

2.思路：

　　(1)第一趟排序，在待排序數據arr[1],arr[2]...arr[n]選出最小的數據，將其與arr[1]進行交換。

　　(2)第二趟排序：在待排序的arr[2],arr[3].....arr[n]中選出最小的元素與arr[2]進行交換；

　　。。。。。。。

　　(3)如此繼續。第i趟在待排序數據arr[i],arr[i+1]....arr[n]中選出最小的元素與其進行交換，直至全部完成、

　　

 

3.舉例：

　　(1)要排序數組:[10,1,35,61,89,36,55]

　　(2)第一趟排序：[10,1,35,61,89,36,55]

　　　　最小數據是1，將1放在首位，也即1和10位置進行交換

　　　　排序結果為：[1,10,35,61,89,36,55]

　　(3)第二趟排序：

　　　　對[10,35,61,89,36,55]進行比較，10最小，不用交換

　　　　排序結果為：[1,10,35,61,89,36,55]

　　(4)第三趟排序

　　　　對[35,61,89,36,55]進行比較，35最小，不用交換

　　　　排序結果為：　[1,10,35,61,89,36,55]

　　(5)第四趟排序

　　　　對[61,89,36,55]進行比較，36最小，36和61交換

　　　　排序結果為：[1,10,35,36,89,61,55]

　　(6)第五趟排序

　　　　對[89,61,55]進行比較，55最小，55和89交換

　　　　排序結果為：[1,10,35,36,55,61,89]

　　(7)第六躺排序

　　　　對[61,89]進行比較，61最小，不需要交換

　　　　排序結果為：[1,10,35,36,55,61,89]

4.java實現代碼：

import java.util.Scanner;

public class SelectSort {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個數組的大小：");
        int a = sc.nextInt();
        System.out.println("請輸入一個數組：");
        int[] arr = new int[a];
        for (int i=0 ; i<a;i++){
            arr[i]= sc.nextInt();

        }
        selectSort(arr);
    }
    public static  void selectSort(int[] arr){
        //一定要記住判斷邊界條件，很多人不注意這些細節，面試官看到你的代碼的時候都懶得往下看，你的代碼哪個項目敢往里面加？
        if(arr==null||arr.length<2){
            return;
        }
        int temp=0 ;
        //最小元素的位置只需要在前面的length-2個位置上就可以
        for(int i = 0 ; i<arr.length-1;i++){
            int min = i ;
            for (int j=i+1;j<arr.length;j++){
                if(arr[min]>arr[j]){
                    min=j;  //記住最小值的位置
                }
            }
            //交換
            temp = arr[i];
            arr[i]=arr[min];
            arr[min]=temp;

        }
        //遍歷數組
        for(int k = 0 ;k<arr.length;k++){
            System.out.print(" "+arr[k]);
        }

    }
}

import java.util.Arrays;
public class SelectSort {

    public static  void selectSort(int[] arr){
        //一定要記住判斷邊界條件，很多人不注意這些細節，面試官看到你的代碼的時候都懶得往下看，你的代碼哪個項目敢往里面加？
        if(arr==null||arr.length<2){
            return;
        }
        int temp=0 ;
        //最小元素的位置只需要在前面的length-2個位置上就可以
        for(int i = 0 ; i<arr.length-1;i++){
            int min = i ;
            for (int j=i+1;j<arr.length;j++){
                if(arr[min]>arr[j]){
                    min=j;  //記住最小值的位置
                }
            }
            //交換
            temp = arr[i];
            arr[i]=arr[min];
            arr[min]=temp;

        }

    }
    public static void main(String[] args) {
        int testTime=500000;
        int size = 10;
        int value=100;
        boolean succeed = true;
        for(int i = 0 ;i<testTime;i++){
            int[] arr1 = generateRandomArray(size,value);
            int[] arr2 = copyArray(arr1);
            int[] arr3= copyArray(arr1);
            selectSort(arr1);
            rightMethod(arr2);
            if(!isEqual(arr1,arr2)){
                succeed=false;
                printArray(arr3);
                break;
            }
        }
        System.out.println(succeed ? "Nice!" : "Fucking fucked!");

        int[] arr = generateRandomArray(size, value);
        printArray(arr);
        selectSort(arr);
        printArray(arr);
    }
    //產生一個隨機數組，數組的長度和值都是隨機的，
    public static  int[] generateRandomArray(int size,int value){
        //在java中，Math.random() ->double(0,1)
        //(int)((size+1)*Math.random())--->產生的是[0,size]之間的整數
        //生成長度隨機的數組，數組的最大長度是size的長度
        int[] arr = new int[(int)((size+1)*Math.random())];
        for(int i = 0 ;i<arr.length;i++){
            //針對數組中的每個值都可以隨機一下，一個隨機數減去另外一個隨機數，可能產生正數，也可能產生負數
            arr[i]=(int)((value+1)*Math.random())-(int)(value*Math.random());//值也可以是隨機的
        }
        return arr;
    }
    //復制數組
    public static int[] copyArray(int[] arr){
        if(arr==null){
            return null;
        }
        int[] res = new int[arr.length];
        for(int i = 0 ;i<arr.length;i++){
            res[i]=arr[i]  ;
        }
        return res;
    }
    //絕對正確的方法,這個方法可以時間復雜度很差，但是要保證其准確性
    public static void rightMethod(int[] arr){
        Arrays.sort(arr);
    }
    //
    public static boolean isEqual(int[] arr1,int[] arr2){
        if(arr1==null&&arr2!=null||arr1!=null&&arr2==null){
            return false;
        }
        if (arr1==null&&arr2==null){
            return true;
        }
        if (arr1.length!=arr2.length){
            return false;
        }
        for(int i = 0;i<arr1.length;i++){
            if(arr1[i]!=arr2[i]){
                return false;
            }
        }
        return true;
    }
    //打印出數組
    public static void printArray(int[] arr){
        if(arr==null){
            return;
        }
        for(int i = 0 ;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }

}

 　　算法時間復雜度同樣還是O(N^2)，記住選擇排序的時間復雜度與數據狀況無關。