选择排序及其优化方案

选择排序

1. 基本思想
2. 运行轨迹
3. 代码实现
4. 性能分析
5. 优化方案

1、基本思想

这是一种思路最简单的排序算法。

①、找到数组中最小的那个元素
②、将它和数组的第一个元素交换位置（如果第一个元素就是最小元素那么它就和自己交换）
③、在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置
④、重复执行③，直到将整个数组排序。

为什么叫选择排序？就是因为它在不断地选择剩余元素之中的最小者。

2、运行轨迹

3、代码实现

根据排序算法类的模板实现选择排序（提醒：点蓝字查看详情）

/**
 * 选择排序
 *
 * @author TinyDolphin
 *         2017/5/14 19:20.
 */
public class Selection {
    /**
     * 排序实现
     * @param arr 待排序数组
     */
    public static void sort(Comparable[] arr) {
        int length = arr.length;//数组长度
        for (int indexI = 0; indexI < length; indexI++) {
            //将arr[indexI]和arr[indexI+1...length]中最小的元素交换
            int min = indexI;//最小元素的索引
            for (int indexJ = indexI + 1; indexJ < length; indexJ++) {
                if (less(arr[indexJ], arr[min])) {
                    min = indexJ;
                }
            }
            exch(arr, indexI, min);
        }
    }
    /**
     * 比较两个元素的大小
     * @param comparableA 待比较元素A
     * @param comparableB 待比较元素B
     * @return 若 A < B,返回 true,否则返回 false
     */
    private static boolean less(Comparable comparableA, Comparable comparableB) {
        return comparableA.compareTo(comparableB) < 0;
    }
    /**
     * 将两个元素交换位置
     * @param arr 待交换元素所在的数组
     * @param indexI 第一个元素索引
     * @param indexJ 第二个元素索引
     */
    private static void exch(Comparable[] arr, int indexI, int indexJ) {
        Comparable temp = arr[indexI];
        arr[indexI] = arr[indexJ];
        arr[indexJ] = temp;
    }
    /**
     * 打印数组的内容
     * @param arr 待打印的数组
     */
    private static void show(Comparable[] arr) {
        for (int index = 0; index < arr.length; index++) {
            System.out.print(arr[index] + " ");
        }
        System.out.println();
    }

    /**
     * 判断数组是否有序
     * @param arr 待判断数组
     * @return 若数组有序，返回 true，否则返回 false
     */
    public static boolean isSort(Comparable[] arr) {
        for (int index = 1; index < arr.length; index++) {
            if (less(arr[index], arr[index - 1])) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Integer[] arr = new Integer[]{14, 23, 21, 17, 20, 49, 24, 77, 54, 47, 31};
        sort(arr);
        assert isSort(arr);
        show(arr); //14 17 20 21 23 24 31 47 49 54 77 
    }
}

4、性能分析

交换元素的代码写在内循环之外，每次交换都能排定一个元素，因此交换的总次数是N。所以算法的时间效率取决于比较的次数。

查看代码可以精准得到，0 到 N-1 的任意 indexI 都会进行一次交换和 N-1-indexI次比较，所以对于长度为 N 的数组，选择排序需要大约 N²/2 次比较和 N 次交换。

选择排序的特点：
①、运行时间和输入无关。为了找出最小的元素而扫描一遍数组并不能为下一遍扫描提供什么信息；
②、数据移动是最小的。每次交换都会改变两个数组元素的值，因此选择排序用了 N 次交换——交换次数和数组的大小是线性关系。（其他大部分排序算法的增长数量级都是线性对数或是平方级别的）

5、优化方案

试想，上述方案中的主要思路是，每次遍历剩余元素，找出其中最小值，只排定最小值。

我们这样，每次遍历剩余元素的时候，找出其中最小值和最大值，并排定最小值和最大值。

这样遍历的次数会减少一半。时间复杂度是O（N/2 * N /2），还是平方级别的。但是运行时间有了相应的减少。

方案修改之后的运行轨迹

优化代码

public static void sortPlus(Comparable[] arr) {
    for (int left = 0, right = arr.length - 1; left < right; left++, right--) {
        int min = left;
        int max = right;
        for (int index = left; index <= right; index++) {
            if (less(arr[index], arr[min])) {
                min = index;
            }
            if (less(arr[max], arr[index])) {
                max = index;
            }
        }
        exch(arr, left, min);
        //此处是先排最小值的位置，所以得考虑最大值（arr[max]）在最小位置（left）的情况。
        if (left == max) {
            max = min;
        }
        exch(arr, right, max);
    }
}

测试用例

public static void main(String[] args) {
    int length = 100000; //十万级别
    Integer[] arr = new Integer[length ];
    for (int index = 0; index < length ; index++) {
        arr[index] = new Random().nextInt(length ) + 1;
    }
    long start = System.currentTimeMillis();
    //sort(arr);   //十万级别-耗费时间：83001ms
    sortPlus(arr); //十万级别-耗费时间：54857ms
    long end = System.currentTimeMillis();
    System.out.println("耗费时间：" + (end - start));
    assert isSort(arr);
}

最后，虽然排序算法简单，但是其优化方案是非常好的一个优化思路，也可以考虑使用在别的算法上，不要仅仅局限于此。

注意：编译器默认不适用 assert 检测（但是junit测试中适用），所以要使用时要添加参数虚拟机启动参数-ea
具体添加过程，请参照eclipse 和 IDEA 设置虚拟机启动参数