排序算法（三）插入排序

一、算法的基本思路
1、将指针指向某个元素，假设该元素左侧的元素全部有序，将该元素抽取出来，然后按照从右往左的顺序分别与其左边的元素比较，遇到比其大的元素便将元素右移，直到找到比该元素小的元素或者找到最左面发现其左侧的元素都比它大，停止；
2、此时会出现一个空位，将该元素放入到空位中，此时该元素左侧的元素都比它小，右侧的元素都比它大；
3、指针向后移动一位，重复上述过程。每操作一轮，左侧有序元素都增加一个，右侧无序元素都减少一个。

---

二、示例说明
初始元素：8 2 16 9 7 4 6
第一趟排序：

指针指向第二个元素2，假设2左面的元素为有序的，将2抽离出来，形成8 _16 9 7 4
6，从8开始，2和8比较，发现8>2。将8右移，形成_8 16 9 7 4 6，2插入到8前面的空位，结果：2 8 16 9 7 4 6；

第二趟排序：

指针指向第三个元素16，此时其左边的元素2，8是有序的，将16抽离出来，形成2 8 16 _ 7 4
6，从8开始依次与16比，发现16左侧的元素都比16小。于是无需移动，把16放到空位中，结果仍为：2 8 16 9 7 4 6；

第三趟排序：

指针指向第四个元素9，此时其左面的元素2,8,16为有序的，将9抽离出来，形成2 8 16 _ 7 4
6，从16开始，依次与9比较，发现9<16，将16向后移，形成2 8 _ 16 7 4
6，然后与8比，发现9>8，于是9插入到空位中，结果为：2 8 9 16 7 4 6;

第四趟排序：

指针指向第五个元素7，此时其左面的元素2 8 9 16为有序的，将7抽离出来，形成2 8 9 16 _ 4 6
，从16开始，依次与7比较，发现7<16，将16向后移，形成2 8 9 _ 16 4 6，与9比，发现7<9，将9向后移，形成2 8 _
9 16 4 6 ，然后与8比，发现7<8,将8向后移，形成2 _ 8 9 16 4
6，然后与2比，发现7>2,于是7插入到空位中，结果为：2 7 8 9 16 4 6；

第五趟排序：

指针指向第六个元素4，此时其左面的元素2 7 8 9 16为有序的，将4抽离出来，形成2 7 8 9 16 _ 6
，从16开始，依次与4比较，发现4<16，将16向后移，形成2 7 8 9 _ 16 6，与9比，发现4<9，将9向后移，形成2 7
8 _ 9 16 6 ，然后与8比，发现4<8,将8向后移，形成2 7 _ 8 9 16
6，然后与7比，发现4<7，将7向后移，形成2 _ 7 8 9 16 6然后与2比，发现4>2,于是4插入到空位中，结果为：2 4 7 8
9 16 6；

第六趟排序：

指针指向第七个元素6，此时其左面的元素2 4 7 8 9 16为有序的，将6抽离出来，形成2 4 7 8 9 16 _
，从16开始，依次与6比较，发现6<16，将16向后移，形成2 4 7 8 9 _ 16 ，与9比，发现6<9，将9向后移，形成2 4 7
8 _ 9 16 ，然后与8比，发现6<8,将8向后移，形成2 4 7 _ 8 9 16 4
6，然后与7比，发现6<7,7.将7向后移，形成2 4 _ 7 8 9 16，然后与4比，发现6>4,于是6插入到空位中，结果为：2 4 6
7 8 9 16。

三、算法实现

public class InsertionSort {

    public static void insertionSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = 1; i < arr.length; i++) {
            for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
                swap(arr, j, j + 1);
            }
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

四、时间复杂度、空间复杂度和稳定性
1.时间复杂度

在第一轮排序中，插入排序最多比较一次；在第二轮排序中插入排序最多比较二次；以此类推，最后一轮排序时，最多比较N-1次，因此插入排序的最多比较次数为1+2+…+N-1=N*(N-1)/2。尽管如此，实际上插入排序很少会真的比较这么多次，因为一旦发现左侧有比目标元素小的元素，比较就停止了，因此，插入排序平均比较次数为N*(N-1)/4，所以时间复杂度为O（N^2）。

2.空间复杂度

插入排序过程中元素进行交换，所需要的额外空间为1，因此空间复杂度为O(1）。

3.稳定性

插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开
始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相
等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。