算法复习 : 插入排序原理，记忆，时间复杂度 (7行java实现)

最近啃了一遍吴伟民老师的《数据结构》，记录一些心得。

一种简洁的插入排序 :

　　1.重要概念 : 哨兵

　　1.在我们要排序的数组中，哨兵做为一个辅助的位置，一般是0下标的槽位做为哨兵

　　 2.哨兵位置上记录的数据不是有效的数据，而是临时的数据，比如上面的 ‘ -1 ’就是一个临时数据，具体的怎么个‘临时’法，请看等下的排序过程分析

　　 3.用哨兵的好处 : 在比较过程中，可以减少边界判断条件，无需判断下标是否小于0，书上的解释也将哨兵称为‘监视边界的哨兵’（请看稍后下方的演示）

　　 4.坏处 : 占用了一个槽位的空间，这个槽位除了排序平时是没有用的，但如果我们的数据量远大于1的话，这个空间其实也不是那么重要，尤其是在内存容量较大的情况下

　　排序过程 :

　　1.首先我们定义一个遍历 i 来控制数组的遍历，因为0下标是哨兵，所以我们的 i 从 1 开始

　　我们需要做到的是，i 遍历的过程中，i 指向的下标位置及其左边区域必须都是有序的(除了哨兵)，这一片左边的区域被称为有序区。

　　比如我们遍历过程中， i = 3时，3下标位置及其左边的区域(1, 2下标区域, 哨兵的0下标位置不算)已经是有序的了，我们的目标就是扩大这个有序区，最终让整　　个数组有序

　　按照我们刚刚说的，我们需要先定义一个 i 变量去遍历数组，并且这个遍历从1开始(因为0是哨兵)

public void insertionSort(int[] arr){
        for(int i = 1;){

        }
    }

　　假想我们手里有一副牌，我们知道我们想把手上的牌整成顺序的话，4比9小，比有序的区域小，所以我们知道要把它插入到左边某个位置

　　但如果不是4而是10呢，我们发现它比9大，所以不移动，有序区加上我们这张10也是有序的。

　　类似的，每次 i + 1 下标的元素都会和 i 下标的元素比较（也就是无序区的左边界和有序区的右边界比较），如果 i 下标元素比较大，那么说明有序区的最大值(假设有序区从小到大)，比将要加入有序区的元素大，说明要加入的元素必须往前插。

　　丰富我们的代码：因为用到 i + 1，而 i + 1 <= length - 1 , 所以 i <= length - 2

 public void insertionSort(int[] arr){
　　　　  //i < arr.length - 1 也就是 i <= arr.length - 2
        for(int i = 1; i < arr.length - 1; i ++){
            
        }
    }

　　接下来是加入比较部分 :

 public void insertionSort(int[] arr){
        //其中的j是临时变量用来保留 i + 1，以及之后标记空位，请向下看
　　　　　int j;
　　　　　//i < arr.length - 1 也就是 i <= arr.length - 2
        for(int i = 1; i < arr.length - 1; i ++){
            if(arr[(j = i + 1)] < arr[i]){
                
            }
     }
 }

　　这时候哨兵的功能就要发挥了，我们把 i + 1 位置的元素存在哨兵里

　　代码添加如下 :

public void insertionSort(int[] arr){
        int j;
　　　　//i < arr.length - 1 也就是 i <= arr.length - 2
        for(int i = 1; i < arr.length - 1; i ++){
            if(arr[(j = i + 1)] < arr[i]){
                //设置哨兵
                arr[0] = arr[j]; 
            }
        }
    }

　　哨兵位置的元素(也就是原来i + 1 位置的元素)，比 i 位置的元素小，所以我们确定了应该是哨兵在左边，i 位置元素在右边，所以 i 位置元素先覆盖 i + 1 位置，但是哨兵元素插不插入到 i 位置还不知道，因为 i 位置后面的元素可能比哨兵大。

代码先加入覆盖部分，上述的描述可能比较复杂，下面有对应的图解

public void insertionSort(int[] arr){
        int j;
　　　　 //i < arr.length - 1 也就是 i <= arr.length - 2
        for(int i = 1; i < arr.length - 1; i ++){
            if(arr[(j = i + 1)] < arr[i]){
                //设置哨兵
                arr[0] = arr[j];
                do {
                    //j = i + 1, j - 1 = i
                    arr[j] = arr[j = j - 1];
                    //覆盖后 j = i
                }
            }
        }
    }

图解 :

就像我们的一副牌，我们知道4要往左边插，那我们先把他放在一边

我们发现9比4大，那么把9往右边挪一挪，也就是上述的 i 位置元素覆盖了 i + 1 位的元素

但是4能直接插入到8和9中间（也就是 i 下标位置）吗？答案是不能，因为右边的8，5还比4大！所以我们的4，也就是哨兵，还要和左边继续比较

什么时候停止比较呢？

　假如我们设上述的空位下标为 j，那么空位后面那个需要和哨兵(也就是上图我们抽出来的牌4)位置就是(j - 1)

我们发现，只要抽出来的牌，不小于 j - 1 位置的牌的大小，那么他就可以插到位置 j 上，也就是空位上

同时我们发现，j 是不断往前移动的（减小），而且仔细观察一下，是较大的牌挪动到后一个位置(也就是空位 , 位置 j )之后

j 才要向前移动，因为 j 代表的是空位，而刚刚我们把大的牌挪到后面了，所以 j 理所应当就是大牌移走之后，大牌留下的那个空位

于是我们摸清楚了 4(哨兵) 是怎么插入到有序区的，表示空位位置的变量 j 是怎么变化

1. 当空位 j 之前的位置 (j - 1) 上的元素，大于哨兵的话，j - 1 位置上的元素就要继续往后挪，挪到空位 j 上

2.第1步，挪完后，空位 j 需要往前挪，也就是 j = j - 1

3.当 j - 1 的元素不大于哨兵元素，我们就要把哨兵插入到空位 j 上

按照上面的思想，我们来完善代码 :

public void insertionSort(int[] arr){
        int j;
        for(int i = 1; i < arr.length - 1; i ++){
　　　　　　　　　　//触发比较
            if(arr[(j = i + 1)] < arr[i]){
                //设置哨兵
                arr[0] = arr[j];
                do {
                    //空位的前一个元素(arr[j - 1])挪到空位(arr[j])上
                    //以及挪动后空位 j 往前挪， 也就是j = j - 1
                    arr[j] = arr[j = j - 1];
                    //比较空位前一个元素(arr[j - 1])和哨兵谁大
                    //当前一个元素大的时候，他将继续往后挪
                }while(arr[j - 1] > arr[0]);
                //哨兵插入空位上
                arr[j] = arr[0];
            }
        }
    }