每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小(大)的元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。

二、代码实现

package com.jdk8.SortTest;

public class SelectSortTest {
    public static void main(String[] args){
        int[] params = new int[]{1,9,5,2,7,4,3,8};
        System.out.println("排序前的数据为：");
        display(params);
        selectSorted(params);
        System.out.println("排序后的数据为：");
        display(params);
    }

    public static void display(int[] arrays){
        for(int i = 0;i < arrays.length;i++){
            System.out.print(" " +  arrays[i] + " ");
        }
    }

    private static void selectSorted(int[] params) {
        if(null == params || params.length < 1){
            return ;
        }
        int min = 0;
        int ref = 0;
        for(int i = 0;i < params.length - 1;i++){
            min =  params[i];
            for(int j = i + 1;j < params.length;j++){
                if(min > params[j]){
                    min = params[j];
                    ref = j;
                }
            }
            min =  params[i];
            params[i] = params[ref];
            params[ref] = min;
        }
        System.out.println();
    }
}

运行结果如下:

排序前的数据为：
 1  9  5  2  7  4  3  8 
排序后的数据为：
 1  2  3  4  5  7  8  9 

三、复杂度分析

3.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值较小时，选择排序比冒泡排序快。

3.2、空间复杂度

​ 选择排序的临时变量所占用的空间不随处理数据n的大小改变而改变，即空间复杂度为O(1)。

四、稳定性

​ 选择排序是不稳定的排序方法。

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