算法

要点：每次从剩余的元素中，选出一个最小/最大的值

public class SelectSort<T extends Comparable> {

    public void sort(T[] arr) {
        if (arr != null && arr.length > 1) {
            for (int i = 0; i < arr.length; i++) {
                // 输出排序情况
                for (T in : arr) {
                    System.out.print(in);
                }
                System.out.println();
                int index = i;
                T min = arr[i];
                // 找未排序部分的最小值
                for (int j = i + 1; j < arr.length; j++) {
                    if (arr[j].compareTo(min) < 0) {
                        min = arr[j];
                        index = j;
                    }
                }
                // 交换
                if (index != i) {
                    arr[index] = arr[i];
                    arr[i] = min;
                }
            }
        }
    }

    public static void main(String[] args) {
        Integer[] arr = new Integer[]{1, 3, 8, 7, 6, 9, 5, 4, 3, 2, 0};
        SelectSort ss = new SelectSort();
        ss.sort(arr);
    }

    /**
     * 13876954320 -> 原数组，长度11
     * ^         ^ ->
     * 03876954321 遍历了10 -> 第一次交换，交换完3的原顺序变了，因此不稳定
     *  ^        ^
     * 01876954323 遍历了9 -> 第二次交换
     *   ^      ^
     * 01276954383 遍历了8 -> 第三次交换
     *    ^    ^
     * 01236954783 遍历了7 -> 第四次交换
     *     ^     ^
     * 01233954786 遍历了6 -> 第五次交换
     *      ^ ^
     * 01233459786 遍历了5 -> 第六次交换（未交换）
     *       ^
     * 01233459786 遍历了4 -> 第七次交换
     *        ^  ^
     * 01233456789 遍历了3 -> 第八次交换（未交换）
     *         ^
     * 01233456789 遍历了2 -> 第九次交换（未交换）
     *          ^
     * 01233456789 遍历了1 -> 第十次交换（未交换）
     *           ^
     *
     * 最外层遍历了11次，内层遍历了10 + 9 + ... + 2 + 1次
     * => 遍历次数：n(n - 1)/2
     * => 时间复杂度：O(n2)
     * => 稳定性：不稳定
     */
}