原理

从当前位置到最后，找出最小(或者最大)值，放在当前位置，位置后移。然后重复此过程。

每次都要在剩余未排序的集合中，找到那个最小(或者最大)的值，放到当前位置。所以叫选择排序。

最小或者最大，影响的是降序还升序。

第一次：找到0 ~ n-1范围内的最小值，放在0位置。
第二次：找到1 ~ n-1范围内最小值，放在1位置。
第i次：找到 i ~ n-1范围内最小值，放在i 位置。

图解：

复杂度

时间复杂度 O(n²)
额外空间复杂度 O(1)

代码实现

java 版本

public static void chooseSort(int[] array) {  
    if (array == null || array.length < 2) {  
        return;  
    }  
  
    for (int i = 0; i< array.length; i ++) {  
        int minIndex = i;  
        for (int j = i + 1; j < array.length; j ++) {  
            if (array[minIndex] > array[j]) {  
                minIndex = j;  
            }  
        }  
        if (minIndex != i) {  
            int temp = array[i];  
            array[i] = array[minIndex];  
            array[minIndex] = temp;  
        }  
    }  
}

Kotlin 版本

fun chooseSort(array: IntArray) {  
  
        // 只有一个数，或者没有数，不用排序  
        if (array.size < 2) {  
            return  
        }  
  
        var minIndex: Int  
        for (i in array.indices) {  // i 从 0  到 N-1            minIndex = i  
            for (j in (i + 1) until array.size) {  
                minIndex = if (array[j] < array[minIndex]) {  // 找到最小的那个， 这种方式排序出来的，是增序的。  
                    j  
                } else {  
                    minIndex  
                }  
            }  
  
            // 把最小的值换到最前边来。  
            if(minIndex != i) {  
                val temp = array[i]  
                array[i] = array[minIndex]  
                array[minIndex] = temp  
            }  
        }  
    }

将交换两个数的代码抽象乘一个函数

fun swap(array: IntArray, indexFrom: Int, indexTo: Int) {  
    if (indexTo != indexFrom) {  
        val temp = array[indexFrom]  
        array[indexFrom] = array[indexTo]  
        array[indexTo] = temp  
    }  
}