算法与数据结构——插入排序

    public static <E extends Comparable<E>> void sort(E[] arr){
        for (int i = 0; i < arr.length; i++) {
            // 将 arr[i]插入到合适的位置,每轮排序排的是已排数字的顺序，不是整体数组的顺序
            for (int j = i; j - 1 >= 0 ; j--) {
                if(arr[j].compareTo(arr[j-1]) < 0){
                    swap(arr,j,j-1);
                }else{
                    break;
                }
            }
        }
    }

    private static <E> void swap(E[] arr, int i, int j) {
        E temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

优化插入排序：

   public static <E extends Comparable<E>> void sort2(E[] arr){
        for (int i = 0; i < arr.length; i++) {
            // 将 arr[i] 插入到合适的位置
            E t = arr[i];
            int j;
            for (j = i; j - 1 >= 0 && t.compareTo(arr[j-1]) < 0;j--) {
                arr[j] = arr[j-1];
            }
            arr[j] = t;
        }
    }

上述两个优化循环不变量是：arr[0,n) 已排序，arr[n,arr.length) 未排序

接下来将循环不变量变为：arr[0,n) 未排序，arr[n,arr.length) 已排序

   public static <E extends Comparable<E>> void sort3(E[] arr){
        for (int i = arr.length - 1; i >= 0; i--) {
            // 将 arr[i] 插入到合适的位置
            E t = arr[i];
            int j;
            for (j = i; j < arr.length-1 && t.compareTo(arr[j+1]) > 0;j++) {
                arr[j] = arr[j+1];
            }
            arr[j] = t;
        }
    }

注意：此插入排序并没有优化时间复杂度，时间复杂度还是 O(n^2)，只是在代码执行逻辑上优化了，减少了数据之间的位置转换，位移操作的性能开销小于数据的互换。

对于有序的插入排序，时间复杂度为 O(n)

对于有序的选择排序，时间复杂度仍为O(n^2)

所以：我们对于算法的优化更多的是关注于时间复杂度的优化