数据结构与算法——选择排序算法

选择排序算法的基本思想：按照指定的规则，选出某一元素，根据排序规定交换位置，循环进行，完成排序的要求。

例如：对于一个n维数组arr，假定需要升序排列：

1）第一次，从arr[0]~arr[n-1]中选择最小值，与arr[0]交换

2）第二次，从arr[1]~arr[n-1]中选择最小值，与arr[1]交换

3）第三次，从arr[2]~arr[n-1]中选择最小值，与arr[2]交换

.....................

4）第i次，从arr[i-1]~arr[n-1]中选择最小值，与arr[i-1]交换

5）第n-1次，从arr[n-2]~arr[n-1]中选择最小值，与arr[n-2]交换

通过上述n-1次交换，可以得到从大到小的升序排序结果。

注意，为了避免无效交换，比如在第i次比较时，如果最小值的索引号没有发生变化，则可以不进行交换操作（相当于自己和自己交换，可以省略），此处在代码实现时加上if判断逻辑即可。

为了理解具体过程，下面以数组arr = {101,34,119,1}为例，以上述思想为主导，进行代码分析如下：

 public static void main(String[] args) {
        //对 [101, 34, 119, 1]进行排序
        int[] arr = {101, 34, 119, 1};
        System.out.println("排序前~");
        System.out.println(Arrays.toString(arr));
        selectSort(arr);
    }
 public static void selectSort(int[] arr) {
        //算法技巧：拆分 再综合
        //第一轮排序
        int minIndex = 0;//假定最小的位置
        int min = arr[0];//假定最小的值
        for(int j = 0 + 1; j < arr.length; j++) {
            if(min > arr[j]) {//说明假定的最小不是最小，要重置
                min = arr[j];//重置值
                minIndex = j;//重置位置
            }
        }
        //将最小值放在arr[0]，把arr[0]的值放在arr[minIndex]
        if(minIndex != 0) {//优化，避免不必要的交换
            arr[minIndex] = arr[0];
            arr[0] = min;
        }
        System.out.println("第1轮~");
        System.out.println(Arrays.toString(arr));//[1, 34, 119, 101]

        //第二轮
        minIndex = 1;//假定最小的位置
        min = arr[1];//假定最小的值
        for(int j = 1 + 1; j < arr.length; j++) {
            if(min > arr[j]) {//说明假定的最小不是最小，要重置
                min = arr[j];//重置值
                minIndex = j;//重置位置
            }
        }
        //将最小值放在arr[0]，把arr[0]的值放在arr[minIndex]
        if(minIndex != 1) {
            arr[minIndex] = arr[1];
            arr[1] = min;
        }
        System.out.println("第2轮~");
        System.out.println(Arrays.toString(arr));//[1, 34, 119, 101]

        //第三轮
        minIndex = 2;//假定最小的位置
        min = arr[2];//假定最小的值
        for(int j = 2 + 1; j < arr.length; j++) {
            if(min > arr[j]) {//说明假定的最小不是最小，要重置
                min = arr[j];//重置值
                minIndex = j;//重置位置
            }
        }
        //将最小值放在arr[0]，把arr[0]的值放在arr[minIndex]
        if(minIndex != 2) {
            arr[minIndex] = arr[2];
            arr[2] = min;
        }
        System.out.println("第3轮~");
        System.out.println(Arrays.toString(arr));//[1, 34, 101, 119]
    }

上述排序元素共有四个，因此需要进行3轮排序。在第一轮中，假设索引为0的元素为最小值，然后通过循环和其后3个元素进行比较，若找到最小值，则重置最小值的索引号和对应的元素值，循环判断结束后，得到正确的最小值索引，将arr[0]的值赋给arr[最小值的索引]，将最小值赋给arr[0]，从而达到arr[0]元素与最小值元素位置交换的目的；第二轮中，同理，假设索引号1元素为最小值，通过循环和其后2个元素进行比较，在循环比较结束后，得到重置的最小索引号和元素值，再进行arr[1]与arr[最小值索引号]进行交换的操作，第三轮过程同理。

通过上述分析，可以发现迭代规律，利用循环实现每轮的比较。只要将每一轮中的0,1,2...改为i进行循环即可。代码分析如下：

        //将多轮排序嵌套循环实现
        for (int i = 0; i < arr.length - 1; i++) {//共需判断length-1轮
            int minIndex = i;//假定最小的位置
            int min = arr[i];//假定最小的值
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) {//说明假定的最小不是最小，要重置
                    min = arr[j];//重置值
                    minIndex = j;//重置位置
                }
            }
            //将最小值放在arr[i]，把arr[i]的值放在arr[minIndex]
            if (minIndex != i) {//优化，避免不必要的交换
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
            System.out.println("第" + (i + 1) + "轮~");
            System.out.println(Arrays.toString(arr));//[1, 34, 119, 101]
        }

上面就是通过循环实现选择排序的所有过程，还有对应的运行结果。可以看到需要两层for循环，因此时间复杂度是O(n^2)，这个复杂度和冒泡排序法是一样滴~

tips：先逐步分析，搞清楚流程，再用循环实现排序结果，逻辑会更清晰哦~

通过函数System.CurrentTimeMills()即可得到程序开始和结束时间差~  实现对算法的运行时间进行具象化的分析。

！选择排序的交换次数比冒泡排序的交换次数少，因此排序时间比冒泡时间短~