（六）Java算法：二分插入排序

一、前言

  插入排序常见的有两种：直接插入排序 和 二分插入排序，我们上一篇算法已经讲过了直接插入排序，现在我们就来讲另外一个二分插入排序，在做这个之前，我希望大家一定要了解二分查找算法，不然你会恨懵的，这里我也提供地址给大家学习下：

• 二分查找算法
• 直接插入排序

二、maven依赖

pom.xml

<dependencies>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starterartifactId>
        <version>2.6.0version>
    dependency>

    <dependency>
        <groupId>org.projectlombokgroupId>
        <artifactId>lombokartifactId>
        <version>1.16.14version>
    dependency>
dependencies>

三、实现

  插入排序有很多种编码方式实现，我们先看看它的最基本的实现。

3.1、详解版

/**
 * 二分插入排序（日志的输出只是为了让大家可以看到它排序的逻辑实际中可以去掉）
 *
 * @param arr int[] arr = new int[]{23, 8, 28, 10, 21, 19, 9};
 */
public static void binaryInsertSort(int[] arr) {
    // 获取数组的长度
    int len = arr.length;
    // 遍历数组从索引为1的位置开始，
    for (int i = 1; i < len; i++) {
        log.info("-------------------------------------");
        log.info("第【{}】轮排序前的结果:{}", i, arr);
        // 定义左边索引
        int leftIndex = 0;
        // 定义右边索引
        int rightIndex = i - 1;
        // 定义当前要进行插入排序的数据
        int insertValue = arr[i];
        log.info("第【{}】轮排序,左边索引【{}】,右边索引【{}】,要插入排序的数据为【{}】", i, leftIndex, rightIndex, insertValue);
        // 只要左边索引小于等于右边的索引就进行遍历
        while (leftIndex <= rightIndex) {
            log.info("左边索引值【{}】 小于等于 右边索引值【{}】", leftIndex, rightIndex);
            // 获取中间索引值
            int middleIndex = (leftIndex + rightIndex) / 2;
            log.info("（左边索引值【{}】+右边索引值【{}】）/2得到中间索引值【{}】", leftIndex, rightIndex,middleIndex);
            // 判断待插入排序的数据和中间值进行比较
            if (insertValue >= arr[middleIndex]) {
                // 修改左边索引
                leftIndex = middleIndex + 1;
                log.info("要插入排序的数据【{}】大于等于中间值【arr[{}]={}】，左边索引值（中间索引值【{}】加1）变为【{}】", insertValue, middleIndex, arr[middleIndex], middleIndex, leftIndex);
            } else {
                // 修改右边索引
                rightIndex = middleIndex - 1;
                log.info("要插入排序的数据【{}】小于中间值【arr[{}]={}】，右边索引值（中间索引值【{}】减1）变为【{}】", insertValue, middleIndex, arr[middleIndex], middleIndex, rightIndex);
            }
        }
        log.info("左边索引值【{}】 大于 右边索引值【{}】，退出内层循环", leftIndex, rightIndex);
        if (leftIndex == i) {
            log.info("要插入的位置【{}】和当前位置【{}】一致不用移动数据", leftIndex, i);
        } else {
            log.info("数据【arr[{}]】到【arr[{}]】往后移动，即：", leftIndex, i - 1);
            // 左边索引右边的数据 到 要排序的数据之前的数据 都往后移动一位
            for (int j = i; j > leftIndex; j--) {
                log.info("数据【arr[{}]】移动到【arr[{}]】", j - 1, j);
                // arr[j-1]移动到arr[j]
                arr[j] = arr[j - 1];
            }
            log.info("要插入排序的数据【{}】插入到【arr[{}]】的位置", insertValue, leftIndex);
            // 要插入排序的数据插入到左边索引的位置
            arr[leftIndex] = insertValue;
        }
        log.info("第【{}】轮排序后的结果:{}", i, arr);
    }
}

public static void main(String[] args) {
    int[] arr = new int[]{8, 10, 9, 23, 21, 19};
    log.info("要排序的初始化数据：{}", arr);
    //从小到大排序
    binaryInsertSort(arr);
}

运行结果：

要排序的数据:[8, 10, 9, 23, 21, 19]
-------------------------------------
第【1】轮排序前的结果:[8, 10, 9, 23, 21, 19]
第【1】轮排序,左边索引【0】,右边索引【0】,要插入排序的数据为【10】
左边索引值【0】 小于等于 右边索引值【0】
（左边索引值【0】+右边索引值【0】）/2得到中间索引值【0】
要插入排序的数据【10】大于等于中间值【arr[0]=8】，左边索引值（中间索引值【0】加1）变为【1】
左边索引值【1】 大于 右边索引值【0】，退出内层循环
要插入的位置【1】和当前位置【1】一致不用移动数据
第【1】轮排序后的结果:[8, 10, 9, 23, 21, 19]
-------------------------------------
第【2】轮排序前的结果:[8, 10, 9, 23, 21, 19]
第【2】轮排序,左边索引【0】,右边索引【1】,要插入排序的数据为【9】
左边索引值【0】 小于等于 右边索引值【1】
（左边索引值【0】+右边索引值【1】）/2得到中间索引值【0】
要插入排序的数据【9】大于等于中间值【arr[0]=8】，左边索引值（中间索引值【0】加1）变为【1】
左边索引值【1】 小于等于 右边索引值【1】
（左边索引值【1】+右边索引值【1】）/2得到中间索引值【1】
要插入排序的数据【9】小于中间值【arr[1]=10】，右边索引值（中间索引值【1】减1）变为【0】
左边索引值【1】 大于 右边索引值【0】，退出内层循环
数据【arr[1]】到【arr[1]】往后移动，即：
数据【arr[1]】移动到【arr[2]】
要插入排序的数据【9】插入到【arr[1]】的位置
第【2】轮排序后的结果:[8, 9, 10, 23, 21, 19]
-------------------------------------
第【3】轮排序前的结果:[8, 9, 10, 23, 21, 19]
第【3】轮排序,左边索引【0】,右边索引【2】,要插入排序的数据为【23】
左边索引值【0】 小于等于 右边索引值【2】
（左边索引值【0】+右边索引值【2】）/2得到中间索引值【1】
要插入排序的数据【23】大于等于中间值【arr[1]=9】，左边索引值（中间索引值【1】加1）变为【2】
左边索引值【2】 小于等于 右边索引值【2】
（左边索引值【2】+右边索引值【2】）/2得到中间索引值【2】
要插入排序的数据【23】大于等于中间值【arr[2]=10】，左边索引值（中间索引值【2】加1）变为【3】
左边索引值【3】 大于 右边索引值【2】，退出内层循环
要插入的位置【3】和当前位置【3】一致不用移动数据
第【3】轮排序后的结果:[8, 9, 10, 23, 21, 19]
-------------------------------------
第【4】轮排序前的结果:[8, 9, 10, 23, 21, 19]
第【4】轮排序,左边索引【0】,右边索引【3】,要插入排序的数据为【21】
左边索引值【0】 小于等于 右边索引值【3】
（左边索引值【0】+右边索引值【3】）/2得到中间索引值【1】
要插入排序的数据【21】大于等于中间值【arr[1]=9】，左边索引值（中间索引值【1】加1）变为【2】
左边索引值【2】 小于等于 右边索引值【3】
（左边索引值【2】+右边索引值【3】）/2得到中间索引值【2】
要插入排序的数据【21】大于等于中间值【arr[2]=10】，左边索引值（中间索引值【2】加1）变为【3】
左边索引值【3】 小于等于 右边索引值【3】
（左边索引值【3】+右边索引值【3】）/2得到中间索引值【3】
要插入排序的数据【21】小于中间值【arr[3]=23】，右边索引值（中间索引值【3】减1）变为【2】
左边索引值【3】 大于 右边索引值【2】，退出内层循环
数据【arr[3]】到【arr[3]】往后移动，即：
数据【arr[3]】移动到【arr[4]】
要插入排序的数据【21】插入到【arr[3]】的位置
第【4】轮排序后的结果:[8, 9, 10, 21, 23, 19]
-------------------------------------
第【5】轮排序前的结果:[8, 9, 10, 21, 23, 19]
第【5】轮排序,左边索引【0】,右边索引【4】,要插入排序的数据为【19】
左边索引值【0】 小于等于 右边索引值【4】
（左边索引值【0】+右边索引值【4】）/2得到中间索引值【2】
要插入排序的数据【19】大于等于中间值【arr[2]=10】，左边索引值（中间索引值【2】加1）变为【3】
左边索引值【3】 小于等于 右边索引值【4】
（左边索引值【3】+右边索引值【4】）/2得到中间索引值【3】
要插入排序的数据【19】小于中间值【arr[3]=21】，右边索引值（中间索引值【3】减1）变为【2】
左边索引值【3】 大于 右边索引值【2】，退出内层循环
数据【arr[3]】到【arr[4]】往后移动，即：
数据【arr[4]】移动到【arr[5]】
数据【arr[3]】移动到【arr[4]】
要插入排序的数据【19】插入到【arr[3]】的位置
第【5】轮排序后的结果:[8, 9, 10, 19, 21, 23]

  眼睛根据数据走，看完你肯定会懂整个流程的，如果还不懂，可能二分查找算法和 直接插入排序还没完全弄懂。

3.2、日志精简版

public static void binaryInsertSort2(int[] arr) {
    // 获取数组的长度
    int len = arr.length;
    // 遍历数组从索引为1的位置开始，
    for (int i = 1; i < len; i++) {
        // 定义左边索引
        int leftIndex = 0;
        // 定义右边索引
        int rightIndex = i - 1;
        // 定义当前要进行插入排序的数据
        int insertValue = arr[i];
        // 只要左边索引小于等于右边的索引就进行遍历
        while (leftIndex <= rightIndex) {
            // 获取中间索引值
            int middleIndex = (leftIndex + rightIndex) / 2;
            // 判断待插入排序的数据和中间值进行比较
            if (insertValue >= arr[middleIndex]) {
                // 修改左边索引
                leftIndex = middleIndex + 1;
            } else {
                // 修改右边索引
                rightIndex = middleIndex - 1;
            }
        }
        // 左边索引右边的数据 到 要排序的数据之前的数据 都往后移动一位
        for (int j = i; j > leftIndex; j--) {
            // arr[j-1]移动到arr[j]
            arr[j] = arr[j - 1];
        }
        // 要插入排序的数据插入到左边索引的位置
        arr[leftIndex] = insertValue;
        log.info("第【{}】轮排序后的结果:{}", i, arr);
    }
}

运行结果：

要排序的数据:[8, 10, 9, 23, 21, 19]
第【1】轮排序后的结果:[8, 10, 9, 23, 21, 19]
第【2】轮排序后的结果:[8, 9, 10, 23, 21, 19]
第【3】轮排序后的结果:[8, 9, 10, 23, 21, 19]
第【4】轮排序后的结果:[8, 9, 10, 21, 23, 19]
第【5】轮排序后的结果:[8, 9, 10, 19, 21, 23]

结语

  二分插入排序是在直接插入排序基础上进行优化的，如果数据列表不是非常的有序的话，理论上二分插入排序 的效率要比 直接插入排序效率要高，尤其是提现在大量的数据进行排序时，但是使用二分插入排序前，先弄懂二分查找算法才会事半功倍。