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

最新推荐文章于 2024-06-16 18:13:53 发布
最新推荐文章于 2024-06-16 18:13:53 发布
阅读量5.5k 收藏 1
点赞数 4
分类专栏： Java常用算法 文章标签： java 算法 排序算法 二分插入排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alian_1223/article/details/125844855
版权

目录

一、前言

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

二、maven依赖

pom.xml

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>2.6.0</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.14</version>
    </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]

结语

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

嘉禾嘉宁papa
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java经典排序算法之二分插入排序详解
08-30
二分插入排序是一种改进的插入排序算法，它利用了二分查找的思想来减少在序列中找到合适插入位置的时间复杂度。在直接插入排序中，为了找到一个元素的正确位置，我们需要从当前元素开始向后逐个比较，直到找到合适的...
Java排序算法总结之插入排序
09-03
二分插入排序利用了二分查找在已排序数组中定位元素的能力，减少了比较次数，但在最坏情况下，时间复杂度仍然是O(n^2)。 ### 总结 插入排序在小规模或部分有序的数据集上表现良好，尤其在实际应用中，当数据近乎...
堆排序
沐雨金鳞
09-25 227
https://img2018.cnblogs.com/blog/1469176/201903/1469176-20190329000545588-1486048945.gif /** * 堆排序演示 */ class HeapSort { public static void main(String[] args) { // int[] arr = {5, 1, 7, 3, 1, 6, 9, 4}; int[] arr = {16, 7, 3, 20, 17,.
java 二分排序_Java经典排序算法之二分插入排序详解
weixin_39885683的博客
02-12 401
一、折半插入排序(二分插入排序)将直接插入排序中寻找A[i]的插入位置的方法改为采用折半比较，即可得到折半插入排序算法。在处理A[i]时，A[0]……A[i-1]已经按关键码值排好序。所谓折半比较，就是在插入A[i]时，取A[i-1/2]的关键码值与A[i]的关键码值进行比较，如果A[i]的关键码值小于A[i-1/2]的关键码值，则说明A[i]只能插入A[0]到A[i-1/2]之间，故可以在A[0...
java高级——Arrays工具类（包含核心的归并和二分排序以及多个底层知识点）
最新发布
蓝桉
06-16 887
Arrays常用方法介绍（8大类） 1. 创建数组 1.1 copyOf（） 1.2 copyOfRange（） 1.3 fill（） 2. 数组转集合：Arrays.asList（常用，也可称为快速初始化集合） 3. 数组比较 3.1 equals（）方法（全部比较以及部分比较） 3.2 deepEquals（）方法 3.3 hashCode()比较 4. 数组排序（重点讲解归并排序以及二分排序） 4.1 普通sort()排序 4.2 增强parallelSort()排序（适用于大数据量）
Java基本排序算法 -- 二分插入排序
书香水墨
07-15 716
二分插入排序 直接插入排序的算法简洁，容易实现，当n较小时时一种好的排序方法。当是一般情况下记录序列中的记录数量都很大，则此时直接插入排序方法就不适用了； 而二分插入排序是在直接插入排序基础上改进的一种排序算法。由于插入排序的操作是在一个有序序列中进行比较和插入的，而比较操作实际上就是在有序序列中作查找操作，这个“查找”操作可以用“二分查找”的方法来实现。按照这种思想，对直接插入排序改进后的排序方法称为二分插入排序，又称折半操作排序。与直接插入排序相比，二分插入排序仅仅减少了记录关键字的比较次数，而记录的
插入排序（Insertion Sort） Java - 直接，折半，2路，表
wowpH
05-22 238
插入排序算法。四种实现方式。1、直接插入排序；2、折半插入排序；3、2路插入排序；4、表插入排序。最常用且最简单的是直接插入排序。它的平均时间复杂度为O(n^2)，空间复杂度为O(1)。
java 二分排序_Java常见排序算法详解—— 二分插入排序
weixin_29069575的博客
02-12 688
转载请注明出处：二分插入排序Binary Insert Sort概念：二分(折半)插入排序是一种在直接插入排序算法上进行小改动的排序算法。其与直接排序算法最大的区别在于查找插入位置时使用的是二分查找的方式，在速度上有一定提升。原理：总共有N个元素，当插入第i个元素时，对前面的0~i-1个元素进行折半，先跟他们中间的那个元素比，如果小，那么再对前半折半，否则对后半进行折半，知道左关说原理可能大家不是...
Java实现直接插入排序和折半插入排序算法示例
09-02
直接插入排序简单直观，而折半插入排序通过二分查找提高了查找效率，但并未减少整体的时间复杂度。尽管它们在平均和最坏情况下的时间复杂度较高，但对于小规模或部分有序的数据，它们的表现仍然可接受。在实际应用中...
java实现插入排序算法
09-03
为了提高插入排序的效率，可以考虑使用二分查找法来确定插入位置，这样可以在O(log n)时间内找到插入点，但总体时间复杂度仍为O(n^2)，只是常数因子有所减小。 5. **与其他排序算法比较**： - **冒泡排序**：冒泡...
java实现二分查找-两种方式
热门推荐
maoyuanming0806的博客
10-08 16万+
二分查找是一种查询效率非常高的查找算法。又称折半查找。 起初在数据结构中学习递归时实现二分查找，实际上不用递归也可以实现，毕竟递归是需要开辟额外的空间的来辅助查询。本文就介绍两种方法 二分查找算法思想 有序的序列，每次都是以序列的中间位置的数来与待查找的关键字进行比较，每次缩小一半的查找范围，直到匹配成功。 一个情景：将表中间位置记录的关键字与查找关键字比较，如果两者相等，
java排序、冒泡、二分、插入、选择等排序方法分析
07-18
描述：冒泡排序 * 特点：算法简单但运行速度慢,算法交换次数和比较次数都是O(N*N) 描述：插入排序 * 特点：插入排序算法任然需要O(N*N),但一般情况下它要比冒泡算法快一倍，比选择排序也快， * 它常用在较复杂的排序算法后阶段<br/> * 使用：数据量较小、基本有序的情况一般选择 插入排序 描述：选择排序 * 特点：优化了冒泡排序，交换次数减少到O(N),比较次数依然为O(N*N) 描述：二分查找发 核心算法 * 注意：mid = (low + high) >>> 1 不能使用(low +　high)/2,因为如何low+high>Integer.MAX_VALUE时会发生溢出
快速排序和二分查找
06-10
通过快速排序对java对象集进行升序排序且随之进行十分查找
二分法插入排序的java简单实现
m0_37777640的博客
05-04 1074
二分法的排序，其实现如上。变量的是怎么变化的需要理解
插入排序（二分优化）（java）
asscwf的博客
04-19 732
核心code： public class insertsort { public insertsort() { } public static void main(String[] args) { int[] a = new int[]{1, 4, 3, 5, 2, 7}; insertsort insertsort = new insertsort(); insertsort.insert(a); int[] v
Java实现二分插入排序
umgsai的专栏
08-10 104
/***“二分插入排序”，利用二分查找优化插入排序中的定位部分。 *《算法导论》，习题2.3-6 *Observethatthewhileloopoflines5-7oftheINSERTION-SORTprocedurein *Section2.1usesalinearsearchtoscan(backward)throughthesorted *subarrayA[1j-1].C...
基础算法（三）---二分排序（Java）
狮锅艺
06-12 1600
目前主流的二分排序是：折半插入排序
Java使用二分插入排序竟然和直接插入排序速度比较
每一天都有新的希望
01-07 2064
Java使用二分插入排序竟然和直接插入排序速度比较
JAVA实现三种排序算法+二分查找算法
KyrieCao的博客
08-28 3593
冒泡排序 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。 其核心思想是： 对于一组需要排序的数字，依次将个位置上的数字与逐一与其之后的数字进行比较，如果他们的顺序错误就把他们交换过来。 这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名。 package com.wip.sorting; import java.uti...
Java编程：八大排序算法详解及二分查找
本文涵盖了8种经典的排序算法，包括直接插入排序、希尔排序、冒泡排序、快速排序、直接选择排序、堆排序、归并排序和基数排序。此外，还提及了二分法查找方法。" 在计算机科学和编程领域，排序算法是处理数据的基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值