初识插入排序

插入排序的工作方式非常像人们排序一手扑克牌一样，开始时，我们的左手为空并且桌子上的牌面朝下。然后我们每次从桌子上拿走一张牌，并将它插入左手的正确位置。为了找到一张牌的正确位置，我们从右到左将它与已在手中的每张牌进行比较。

将数组 {12,11,10,9,8,7,6}，正序

原理
1.把所有的元素分为两组，已经排序的和未排序的
2.找到未排序的组中的一个元素，向已经排序的组中进行插入
3.倒叙遍历已经排序的元素，一次和带插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置没其他的元素向后移动一位

public class Insertion {
    public static void main(String[] args) {
        Integer arr[] = {12,11,10,9,8,7,6};
        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 - 1; i++) {
            for (int j = i; j > 0; j--) {
                if (greater(comparator, arr[j - 1], arr[j])) {
                    exch(arr, j, j - 1);
                } else {
                    break;
                }
            }
        }
    }

    /**
     * 正序
     *
     * @param arr
     * @param <T>
     */
    public static <T> void sort(Comparable<T>[] arr) {
        //有多少个元素参与选择 i开始索引  arr.length - 1 所有元素都参与
        for (int i = 0; i <= arr.length - 1; i++) {
            //倒序遍历0至i处的索引， j被比较元素的开始值 ，arr.length - 1倒数第一个元素需要被比较,没有等于是因为下面的j-1
            for (int j = i; j > 0; j--) {
                if (greater(arr[j - 1], arr[j])) {
                    exch(arr, j, j - 1);
                } else {
                    break;
                }
            }
        }
    }

    /**
     * 比较大小，如果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

公式推导
设pn=(n-1）+(n-2)+(n-3)+…+3+2+1
设sn=1+2+3+…+(n-3）+(n-2)+(n-1)
pn+sn=(n-1+1)+(n-2+2)+(n-3+3)+…+(3+n-3)+(2+n-2)+(1+n-1)
因为一共有n-1个数，所以
pn+sn=n(n-1)
因为pn=sn，所以
pn=(n(n-1))/2

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

总执行次数为

2(n^2/2-n/2)=n^2-n

根据大O推导法则，去掉最高项的常数因子，去掉常数项，所以时间复杂度为O(n^2)