直接插入排序

原理：每次将排序中的元素，插入到前面已经排好序的有序序列中去，直到排序完成。

步骤：

第一步，a[0]为有序区，待排序区为a[1..n-1]。令i=1。
第二步，将a[1]与a[0]中元素比较，将小的元素放在第一个位置。
第三步，以此类推，直到待排序中全部元素插入完成为止。

例子：int[] arr={5,2,6,0,9};经行直接插入排序

图解：

过程：

初始状态：设5为有序，其中i为1，即：5 2 0 6 9
第一趟排序：第i个元素2比5小，则插入到5前面，然后i自增，即： 2 5 0 6 9
第二趟排序：第i个元素0比2，5小，则插入到2前面，然后i自增，即：0 2 5 6 9
第三趟排序：第i个元素6比5大，则插入到5后面，然后i自增，即：0 2 5 6 9
第四趟排序：第i个元素9比6大，则插入到6后面，然后i自增，即：0 2 5 6 9
最终的答案为：0 2 5 6 9

时间复杂度：

1.在最好情况下，严格递增的数组，比较次数C和移动次数M为：

C = n - 1
M = 0
时间复杂度为O(n)。

2.在最坏情况下，严格递减的数组，比较次数C和移动次数M为：

C = n(n-1)/2
M = n(n-1)/2
时间复杂度为O(n²)。

综上，时间复杂度为：O_(n²) 。

优缺点：　　

优点 : 稳定，相对于冒泡排序与选择排序更快；
缺点 : 比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量大的时候；

代码：

public class DirectSort {
    
    public static void main(String[] args) {
        // 直接插入排序1
        int[] arr = { 8, 9, 5, 3, 6, 7, 16 };
        
        int j;
        for (int i = 1; i < arr.length; i++) {
            j = i;
            while (j > 0 && arr[j] < arr[j - 1]) {
                int temp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = temp;
                j--;
            }
        }
        
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
        
        // 直接插入排序2
        arr = new int[] { 8, 9, 5, 3, 6, 7, 16 };
        for (int i = 1; i < arr.length; i++) {
            int index = 0;
            for (int k = (i - 1); k >= 0; k--) {
                if (arr[i] > arr[k]) {
                    index = k + 1;
                    break;
                }
            }
            
            int temp = arr[i];
            for (int n = i; n > 0 && n >= index; n--) {
                arr[n] = arr[n - 1];
            }
            arr[index] = temp;
        }
        
        System.out.println("---");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + ",");
        }
        
    }
}