排序算法系列(6)——折半插入排序

上一节讲了直接插入排序，本次讲一个直接插入排序的进阶版——折半插入排序，二者的排序逻辑是一样的，区别在于：

1. 直接插入排序，每次需要插入的元素需要依次比较该元素之前的所有元素来确定其应该插入前面已经排好序的哪个位置。
2. 折半插入排序，通过对前置排好序的列表进行二分比较，先比较中间值，然后确定该元素在中间值的左/右，然后对应在的范围继续进行二分比较，直到确定插入到什么位置。

坐在巨人的肩膀上，感觉图示也没有必要了，折半插入就是直接选择排序+二分法查找，直接上代码整活儿~

    public void binaryInsertionSort(int[] arrays, int start, int end) {
        if (start == end) {
            return;
        }
        for (int i = start + 1; i <= end; i++) {
            // [start, i-1]已经排好序，只要将i插入其中即可
            int low = start;
            int high = i - 1;
            while (low <= high) {
                int middle = (low + high) / 2;
                if (arrays[middle] > arrays[i]) {
                    high = middle - 1;
                } else {
                    low = middle + 1;
                }
            }
            int val = arrays[i];
            // i位置的值应该放在high+1的位置，开始移动
            for (int j = i; j > high + 1; j--) {
                arrays[j] = arrays[j - 1];
            }
            arrays[high + 1] = val;
        }
    }

在写代码的时候呢，其实我发现有两个地方容易写错（也可能是本人水平有限），在此说明一下，填坑。。。

1. 中间值比array[i]大，即找前半部分，否则找后半部分------
   当中间值确定的已经到了low=high时，即中间值没有前后部分了
   只有这一个元素了，也就是快到了跳出while的时候，即low>high
   此时有个纠结的点是array[i]应该插入到low的位置还是high的位置?

此时我们进行分类讨论（此时不妨设置对应索引下标low=high=x）：
① 若arrays[x] > arrays[i]，此时应查找x的左半部分，此时：
-- low = x, high = x - 1; 跳出while,
-- 此时arrays[i]应该放到x位置，将原[x, i-1]位置的数据“挤”到[x+1, i]
② 若arrays[x] <= arrays[i]，此时应查找x的右半部分，此时：
-- low = x + 1, high = x ; 跳出while,
-- 此时arrays[i]应该放到x位置，将原[x+1, i-1]位置的数据“挤”到[x+2, i]

综上，当跳出循环的时候，其实就是将arrays[i]放到low的位置(也就是high+1)，然后将[low, i-1]位置数据放置到[low+1, i]

上面所述的一个究竟将arrays[i]放到哪个位置的问题就迎刃而解了，有的时候脑子思考不清晰，就可以直接举例试一下的方式来解决一下，不一定非得推导出什么公式、定理，我们又不是什么伟大优秀的数学天才，数形结合，分类讨论，能解决问题就行。

其次，在做相应位置的赋值的时候我也犯迷糊了，连翻两车，记录一下。。。
正确代码:

            int val = arrays[i];
            // i位置的值应该放在high+1的位置，开始移动
            for (int j = i; j > high + 1; j--) {
                arrays[j] = arrays[j - 1];
            }
            arrays[high + 1] = val;

第一车：

            // i位置的值应该放在high+1的位置，开始移动
            for (int j = high+1; j < i; j++) {
                arrays[j+1] = arrays[j];
            }
            arrays[high + 1] = val;

这车翻的彻底，直接依次将[high+1, i-1]的值赋值到[high+2, i]，然后最后导致我打印排序结果出来很多相同的值，稍微看了一下，还是自己犯蠢了：
arrays[i+2] = arrays[i+1];
arrays[i+3] = arrays[i+2];
尴尬三连：i+2的值已经被赋值为了i+1的值了，那i+2的值给i+3不还是归根到底讲i+1的值给覆盖过去了。。。尴尬癌晚期

第一车翻彻底后，醒悟了翻了第二车：

            // i位置的值应该放在high+1的位置，开始移动
            for (int j = i; j > high + 1; j--) {
                arrays[j] = arrays[j - 1];
            }
            arrays[high + 1] = val;

这下我倒着移动赋值:
先将i-1位置的值赋值到i位置
先将i-2位置的值赋值到i-1位置
以此类推，结束赋值，这样倒序赋值就不会出现覆盖的情况

最后还是出现了类似第一车的结果，
仔细观察正确代码和第二车的差异，不难发现，其实就是将i位置原来的值取出来罢了，因为在移动赋值时会将i位置值覆盖为i-1的值，所以最终high+1位置并不是赋值为了原i位置的值，而是原i-1位置的值。
究其根本，是因为i位置值被i-1位置覆盖了，需要提前使用中间值存储，否则i位置原本的值就被覆盖掉了。。。

原本我觉得此算法同直接插入排序差不多，不就是比较通过二分法进行快速区分范围确定插入元素应在已排序的前置数组中的位置，然后将被"挤"出去的列表块一同往后移动一个位置，但是写出来还是翻车了
最终也是印证了一句话：嘴强王者没卵用，纸上得来终觉浅，该撸代码还得撸！