初识选择排序

将数组{4,6，8,7，9,2，10,1}，正序排列
原理
1.在每一次遍历过程中，都假定第一个索引处的元素是最小值，和其他索引初的值依次进行比较，如果假定的索引处的值大于其他某个索引初的值，则假其他某个索引初的值为最小值，最后可以找到最小值所得的索引
2.交换第一个索引处和最小值所在的索引处的值

Selection中包含2个方法，默认正序sort(Comparable[] arr)和自定义顺序sort(T[] arr,Comparator comparator)

public class Selection {

    public static void main(String[] args) {
        Integer arr[] = {4, 6, 8, 7, 9, 2, 10, 1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
        sort(arr, Comparator.reverseOrder());
        System.out.println(Arrays.toString(arr));
    }


    /**
     * 自定义排序
     *
     * @param arr
     * @param comparator
     * @param <T>
     */
    public static <T> void sort(T[] arr, Comparator<T> comparator) {

        for (int i = 0; i <= arr.length - 2; i++) {
            int minIndex=i;
            for (int j = i+1; j <= arr.length - 1; j++) {
                if (greater(comparator, arr[minIndex], arr[j])) {
                    minIndex=j;
                }
            }
            exch(arr,i,minIndex);
        }
    }


    /**
     * 正序
     *
     * @param arr
     * @param <T>
     */
    public static <T> void sort(Comparable<T>[] arr) {
        //有多少个元素参与选择 i开始索引  arr.length - 2倒数第一个元素不用选择了
        for (int i = 0; i <= arr.length - 2; i++) {
            //定义一个变量，记录最小元素所在的索引，默认参与选择排序的第一个元素所在位置，倒数第二还是需要的
            int minIndex = i;
            //参加选择排序的元素每次都少一个， j被比较元素的开始值 ，arr.length - 1倒数第一个元素需要被比较
            for (int j = i + 1; j <= arr.length - 1; j++) {
                if (greater(arr[minIndex], arr[j])) {
                    minIndex = j;
                }
            }
            exch(arr, i, minIndex);
        }
    }

    /**
     * 比较大小，如果c1比c2大，返回true,否则false，正序
     *
     * @param c1
     * @param c2
     * @return
     */
    private static boolean greater(Comparable c1, Comparable c2) {
        return c1.compareTo(c2) > 0 ? Boolean.TRUE : Boolean.FALSE;
    }

    private static <T> boolean greater(Comparator comparator, T c1, T c2) {
        return comparator.compare(c1, c2) > 0 ? Boolean.TRUE : Boolean.FALSE;
    }

    /**
     * 将arr数组中i角标和j角标位置互换
     *
     * @param arr 数组
     * @param i   角标
     * @param j   角标
     * @param <T>
     */
    private static <T> void exch(T[] arr, int i, int j) {
        T temp;
        temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;

    }
}

时间复杂度分析
冒泡排序使用了双层for,其中内存循环的循环体是真正完成排序的代码，所以我们分析冒泡排序的时间复杂度，主要分析一下内层循环的执行次数即可

元素的比较次数为
（n-1）+(n-2)+(n-3)+…+3+2+1=n^2/2-n/2
元素的交换次数为
n-1

时间复杂度为n^{2/2-n/2+n+1=n}2/2+n/2+1
根据大O推导法则，去掉最高项的常数因子1/2，去掉常数项n/2和1，所以时间复杂度为O(n^2)，不适合数据量大的情况

备注：如果想优化，可以在交互位置的时候判断一下两个角标的是否相等，相等则不用交换