插入排序:二路插入

2-路插入排序 /* 2-路插入排序 算法思想:增加一个辅助空间d,把r[1]赋值给d[1],并将d[1]看成是排好序后处于中间 位置的记录。然后从r[2]开始依次插入到d[1]之前或之后的有序序列中。 时间复杂度 o(n^2) 空间复杂度 o(1) 比较次数 n(n+1)/2 */ void bi_insert_sort(int array[],int len) { int* arr_d = (in 阅读详情

作者:苏叔叔

链接:http://blog.youkuaiyun.com/zhangxiangdavaid/article/details/27958143?utm_source=tuicool&utm_medium=referral

在上一篇博客中:插入排序:直接插入、交换插入、折半插入。提到了三种插入排序的具体实现。不过仍有改进的地方。例如序列 2 1 3,当把1往前插入时,由于1<2,则应当把1插入到2的前面。在上述三种插入排序方法的实现中,都是把1、2位置交换。于是,我们想有没有可能不进行交换,因为交换总是相当耗时的。但是1必须要排到2的前面,可2的前面没有位置了啊?嗯,初看是这样的。试想这是一个循环的数组呢?这就是二路插入最核心的想法。

思路:

  1. 构建一相同大小的循环数组b,把原数组的元素依次插入,最后按合适次序赋值回原数组。如何实现循环呢?有办法的。可参考约瑟夫问题的数组解法中是如何实现的。
  2. 把原数组的第一个值a[0]复制过去,b[0]=a[0],作为循环数组的第一个数。当然,也可选择其它的数作为第一个数。
  3. 若a[i]<b[first],则变化first:first=(first-1+n)%n,b[first]=a[i]
  4. 若a[i]>=b[last],则变化last:last++(注意这里没必要这样写:last=(last+1)%n),b[last]=a[i]
  5. 若b[first]<=a[i]<b[last],则选择适当的策略,插入下图中的一路位置。
  6. 这里的二路是什么意思?没有看到哪里解释过,我的理解是,看下图:

上图中,first指向已拍好序列的第一个,last指向已排好序列的最后一个。如果按从小到大排序,first指向最小,last指向最大的。如果某一个数据a,且b[first]<=a<b[last],则a应插入图中一路所示的位置,其它的应插入二路。也就是说,可以插入的位置总的分为两路-二路插入。
显然,一路位置的元素是有序的。那么在往一路插入时,可直接插入,也可二分插入,先看下直接插入时的代码:
代码一:
[cpp]  view plain  copy
  1. <span style="font-size:25px;">  
  2. void InsertSort1(int a[], int n)    //二路插入  
  3. {  
  4.     int first, last;  
  5.     first = last = 0;  
  6.     int *b = new int[n];  
  7.     b[0] = a[0];  
  8.     for (int i = 1; i < n; i++)  
  9.     {  
  10.         if (a[i] < b[first])  
  11.         {  
  12.             first = (first - 1 + n) % n;   //first的变化必须这样写  
  13.             b[first] = a[i];  
  14.         }  
  15.         else if (a[i] >= b[last])  
  16.         {  
  17.             last++;     //有的人这样写:last=(last+1)%n,其实没必要,last是不会超过n-1的。  
  18.             b[last] = a[i];  
  19.         }  
  20.         else  
  21.         {  
  22.             int k;  
  23.             for (k = last+1; a[i] < b[(k-1+n)%n]; k=(k-1+n)%n)     // 使用直接插入  
  24.                 b[k] = b[(k - 1 + n)%n];  
  25.             b[k] = a[i];  
  26.             last++;  
  27.         }  
  28.     }  
  29.     for (int i = 0; i < n; i++)  
  30.         a[i] = b[(i + first) % n];  
  31.     delete[]b;  
  32. }  
  33. </span>  

显然,在对一路二分插入时,更高效,代码如下:
代码二:在二分查找时,我们选择左闭右开的区间。 若是无法理解折半查找的过程,强烈推荐看下: 插入排序:直接插入,交换插入,折半插入
[cpp]  view plain  copy
  1. <span style="font-size:25px;">  
  2. void InsertSort2(int a[], int n)    //二路插入  
  3. {  
  4.     int first, last;  
  5.     first = last = 0;  
  6.     int *b = new int[n];  
  7.     b[0] = a[0];  
  8.     for (int i = 1; i < n; i++)  
  9.     {  
  10.         if (a[i] < b[first])  
  11.         {  
  12.             first = (first - 1 + n) % n;  
  13.             b[first] = a[i];  
  14.         }  
  15.         else if (a[i]>=b[last])  
  16.         {  
  17.             last++;  
  18.             b[last] = a[i];  
  19.         }  
  20.         else  
  21.         {  
  22.             int low, high, mid, d;  
  23.             low = first, high = last;  
  24.             while (low != high)      //折半查找  
  25.             {  
  26.                 d = (high-low+n) % n;    //元素个数  
  27.                 mid = (low + d / 2) % n;    //中间位置  
  28.                 if (a[i] < b[mid])  
  29.                     high = mid;  
  30.                 else  
  31.                     low = (mid + 1) % n;  
  32.             }  
  33.             for (int k = last + 1; k != low; k = (k - 1 + n) % n)  //移动元素  
  34.                 b[k] = b[(k - 1 + n) % n];  
  35.             b[low] = a[i];  
  36.             last++;  
  37.         }  
  38.     }  
  39.     for (int i = 0; i < n; i++)  
  40.         a[i] = b[(i + first) % n];  
  41.     delete[]b;  
  42. }  
  43. </span>  

update: 2014-6-2 0:11
下面给出一测试代码,详细观察数组b的变化情况,
[cpp]  view plain  copy
  1. #include<stdio.h>  
  2. #include<stdlib.h>  
  3. #include<string.h>  
  4. void printArray(int a[], int n)   //打印数组   
  5. {  
  6.     for (int i = 0; i<n; i++)  
  7.         printf("%-4d", a[i]);  
  8.     printf("\n");  
  9. }  
  10. void InsertSort2(int a[], int n)    //二路插入  
  11. {  
  12.     int first, last;  
  13.     first = last = 0;  
  14.     int *b = new int[n];  
  15.     memset(b,0,n*sizeof(int));   //数组b的内存空间清零  
  16.     b[0] = a[0];  
  17.     printf("数组下标:\n");  
  18.     for (int i = 0; i < n; i++)  
  19.         printf("%-4d",i);  
  20.     printf("\n");  
  21.     printf("数组b的变化\n");  
  22.     for (int i = 1; i < n; i++)  
  23.     {  
  24.         printArray(b, n);  
  25.         if (a[i] < b[first])  
  26.         {  
  27.             first = (first - 1 + n) % n;  
  28.             b[first] = a[i];  
  29.         }  
  30.         else if (a[i]>=b[last])  
  31.         {  
  32.             last++;  
  33.             b[last] = a[i];  
  34.         }  
  35.         else  
  36.         {  
  37.             int low, high, mid, d;  
  38.             low = first, high = last;  
  39.             while (low != high)      //折半查找  
  40.             {  
  41.                 d = (high-low+n) % n;    //元素个数  
  42.                 mid = (low + d / 2) % n;    //中间位置  
  43.                 if (a[i] < b[mid])  
  44.                     high = mid;  
  45.                 else  
  46.                     low = (mid + 1) % n;  
  47.             }  
  48.             for (int k = last + 1; k != low; k = (k - 1 + n) % n)  
  49.                 b[k] = b[(k - 1 + n) % n];  
  50.             b[low] = a[i];  
  51.             last++;  
  52.         }  
  53.     }  
  54.     printArray(b,n);  
  55.     for (int i = 0; i < n; i++)  
  56.         a[i] = b[(i + first) % n];  
  57.     delete[]b;  
  58. }  
  59. int main()  
  60. {  
  61.     const int N = 6;  
  62.     int a[N];  
  63.     srand((unsigned)time(NULL));  
  64.     printf("原数组a\n");  
  65.     for (int i = 0; i < N; i++)  
  66.     {  
  67.         a[i] = rand() % 100;  
  68.         printf("%-4d",a[i]);  
  69.     }  
  70.     printf("\n");  
  71.     InsertSort2(a, N);  
  72.     printf("经排序后的数组a\n");  
  73.     printArray(a, N);  
  74.     printf("\n");  
  75.     system("pause");  
  76.     return 0;  
  77. }  
某一次的运行结果是这样的:


小结:
  1. 这里我们使用的区间是左闭右开的,这是为了方便后面循环的终止。
  2. 关于first和last的移动,大家画下图,很容易明白。从上面的运行结果可以看出,last是从0开始递增的,且不会超过n-1,这一点是显然的。
  3. 在往二路插入时,是不需要移动元素的,这就是二路插入相对于前三种改进的地方。
  4. 若a[0]即是最小或最大的元素,则退化为直接插入,此时无法减少移动次数。
  5. 在代码二中,关于元素个数d=(high-low+n)%n,要注意:由于这里选取的是左闭右开的区间[low,high),好比区间[1,2)中整数个数是2-1=1,但在区间[1,2]中整数个数是2-1+1=2,所以这里是high-low,后面的+n,你懂的。若是写成d=(high-low+1+n)%n,会进入死循环,你可以试一下。


代码就是折腾,多折腾才有进步!


若是有所帮助,顶一个哦!


    所有内容的目录


    几何修复_ANSYS流体分析:几何前处理 建模及几何处理工具非常多,选择起来让人眼花缭乱。对于仿真而言,高效的对几何进行清理及生成符合仿真要求的几何至关重要。ANSYS SpaceClaim Direct Modeler是基于直接建模思想的新一代3D高效率建模和几何编辑修补软件。SCDM提供了当今最快速、最富有创意的直接建模解决方案。由于它的直接建模能力即使对于导入的其它3D模型(如catia、proe、solid works创建的几何)... 阅读详情

    相关推荐

    从URDF到仿真动画:基于Simulink、Simscape与S-Function的机械臂一体化建模与控制

    本文详细介绍了从URDF文件到高保真仿真动画的一体化机械臂建模与控制流程。通过整合Simulink、Simscape与S-Function,构建了包含物理特性的虚拟机械臂模型,并实现了自适应滑模等高级控制算法的嵌入与验证。该流程打通了从机械设计到控制算法验证的闭环,为机器人开发提供了高效的仿真平台。

    cnn8visionary的博客 701

    排序算法:2-路插入排序

    2-路插入排序算法是一种变体的插入排序算法,通常用于对数组进行排序。该算法使用两个有序子序列,一个递增有序子序列和一个递减有序子序列,来加快排序过程。同一元素可能会分别被插入到递增子序列和递减子序列中,而该元素在递增子序列和递减子序列内的相对位置取决于其在原始数组中的位置,因此该算法是稳定的。数据量较小、数据已近部分有序的排序场景。

    jingbeng11 1270

    ESP32-BLE学习1-建立简单的server

    start 学习之前,我想尝试使用ESP32的demo建立一个简单的server与手机接进行最基本的数据通信。 这里有BLE的简单讲解BLE资料 因为BLE的连接是具有主从机特性的,就像SPI,USB一些请求只能由主机端发起,连接也需要主机端发起。所以手机要想连上ESP32,就得将ESP32设置为从机模式。 从资料上可以看到,从机端通过Notify通知主机,所以从机就是GATT Server。 在进行ESP32 的demo学习之前,得大体看下ESP32的蓝牙组成,ESP32支持经典蓝牙和低功耗蓝牙4.2,

    Spark的博客 1845

    2-路插入排序(Two-Way Insertion Sort)

    算法介绍   2-路插入排序是在折半插入排序的基础上改进的,插入排序的时间主要花在比较和移动这两种操作上。2-路插入排序可以减少排序过程中移动记录的次数,但为此需要借助n个记录的辅助空间。 算法描述   利用一个与排序序列一样大小的数组作为辅助空间,设置first和final指针标记辅助数组开始位置和最后位置。遍历未排序序列,如果待插入元素比已排序序列最小的元素(first位置)小,则first位置前移,将待排序元素插入first位置;如果待插入元素比已排序序列最大的元素(final位置)大,则final位

    Acx7的博客 2839

    微电网模型Matlab Simulink,风光储微电网,永磁风机并网仿真,光伏并网仿真,蓄电池仿真

    通过探究风光储微电网、永磁风机并网仿真、光伏并网仿真、蓄电池仿真、柴油发电机以及光储微电网和风储微电网等方面的技术,我们可以更好地理解微电网的工作原理和优化方法,从而为微电网的发展做出更大的贡献。微电网模型Matlab Simulink,风光储微电网,永磁风机并网仿真,光伏并网仿真,蓄电池仿真,柴油发电机,光储微电网 风储微电网 Matlab仿真平台搭建的风光储微电网模型,风光柴储微电网,pwm控制,风力发电,光伏发电,微电网并网离网切换,并网孤岛切换,功能强大。永磁风机的并网仿真是一个非常重要的环节。

    sjbextz的博客 401

    UE5网络模块实战:属性复制、RPC与联机开发踩坑指南

    多人联机开发中,网络同步是核心难题。UE5网络模块以服务器权威为基础,通过Actor复制、RPC和所有权机制实现多端状态一致。理解属性复制与OnRep回调、区分Server/Client/Multicast RPC的适用场景,是构建稳定联机架构的关键。本文结合数字孪生与多端协作场景,探讨如何将渲染与逻辑分离,并针对打包后网络失效、端口防火墙、崩溃排查等工程实践问题给出解决方案。通过蓝图接口解耦表现层,利用C++创建StaticMesh组件实现服务器逻辑与客户端表现分离,同时注意专用服务器不加载渲染依赖(如D

    weixin_29010003的博客 274

    【笔记】2-路插入排序

    插入排序:将待排序元素分为已排序子集和未排序子集,一次从未排序子集中的一个元素插入已排序子集中,使已排序自己仍然有序;重复执行以上过程,指导所有元素都有序为止。   2-路插入排序是在折半插入排序的基础上再改进,其目的是减少排序过程中移动记录的次数,但为此需要n个记录的辅助空间。   基本算法思想:另设一个与L.r同类型的数组d,首先将L.r[1]赋值给d[1],并将d[1]看成是在排好

    time-space的博客 886

    Alipay 支付唤起 h5 测试

    测试地址 https://recharge.apps.oppomobile.com/recharge-center/recharge/?from=message try { //唤起客户端快捷参数 var data = {"requestType":"SafePay","fromAppUrlScheme":"alipays","dataString":"h5_ro...

    六桥风月IT随笔 1万+

    (1.3.3.1)插入排序:二路插入

    在上一篇博客中:插入排序:直接插入、交换插入、折半插入。提到了三种插入排序的具体实现。不过仍有改进的地方。例如序列 2 1 3,当把1往前插入时,由于1 思路: 构建一相同大小的循环数组b,把原数组的元素依次插入,最后按合适次序赋值回原数组。如何实现循环呢?有办法的。可参考约瑟夫问题的数组解法中是如何实现的。把原数组的第一个值a[0]复制过去,b[0]=a[0]

    JAVA成长之路 887

    DIC新手避坑指南:压缩实验中的应变测量常见错误与数据校验技巧

    本文为DIC技术新手提供了压缩实验中应变测量的全面避坑指南。文章系统梳理了从试样尺寸录入、散斑质量到数据后处理中应变方向与符号混淆、数据插值对齐等常见错误,并分享了基于MATLAB的自动化数据校验与可视化对比技巧,帮助建立可靠的实验数据分析SOP,确保DIC测量结果的准确性。

    weixin_29313423的博客 115

    Unity游戏接入穿山甲广告SDK全攻略:从零到上线的避坑指南

    本文为Unity开发者提供了接入穿山甲广告SDK的完整实战指南。详细解析了从账号注册、应用创建到Unity插件集成、安卓与iOS平台打包配置的全流程,并重点分享了广告加载失败、展示异常等常见问题的排查与解决方案,帮助开发者高效实现游戏广告变现。

    weixin_29015899的博客 538

    插入排序优化:简单插入排序->二分查找插入排序->二路插入排序->shell插入排序

    #include void ShellInsertSort(int r[],int n,int dk) {     int i;     for(i=dk;i     {         if(r[i]         {             int j = i-dk;             int x = r[i];             while(x=0)

    Faded0104的博客 1083

    lammps案例:扭转

    扭转有两种方式,一是固定一端旋转另外一端,二是两端沿相反的方向旋转。案例为两侧旋转方式,扭转后的效果如图所示。

    lammps_jiayou的博客 1201

    【插入排序】直接,折半,二路,希尔

    插入排序 给出一下四种方法: 直接插入排序,折半插入排序,二路插入排序,希尔插入排序 代码实现: #include using namespace std; #define size 21 typedef int Sqlist[size]; void SInsertSort(Sqlist &L, int n) //直接插入 { cout << "直接插

    Irean_Lau的专栏 1708

    华为的C语言编程规范.pdf

    华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

    锂电池充电器电路设计 里面有电路

    锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

    插入排序总结

    简单插入排序: #include #include #include #include using namespace std; int main (void) { int i, j; int arr[100]; int num; while (scanf ("%d", &num) != EOF) { for (i = 1;i <= num;i++) { scanf (

    谈笑风声,雨下成林 363

    大中型超市收银系统(可直接运行)

    光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

    MIT:算法导论——第一课:算法分析——插入排序 vs 二路归并排序

    sss

    我和编程有个约定的专栏 640

    直接插入排序,折半插入排序和2路插入排序的算法C++语言的实现

    直接插入排序,折半插入排序和2路插入排序的算法C++语言的实现

    m0_61973596的博客 1113

    插入排序

    1.直接插入排序 思路:从i开始遍历,i之前为已经排序好的数组,从0至i-1遍历,如果遇到比i小的数字,就交换 代码: #include<iostream> using namespace std; class List{ public: List(){ array=NULL; } void creat(){ int n; cout<<"请输入数组大小:"; cin>>n; this->n=n; array=new

    陈同学的博客 165

    MIT:算法导论——1.算法分析——插入排序 vs 二路归并排序

    #if 0 Input:5 2 4 7 1 3 2 6 #endif #if 1 #include #include #include #include #include using namespace std; template int insertionSort( T* data, int n ); template

    loveprogram_1的专栏 710

    JAVA实现排序-插入排序-2路插入排序

    package insert;/* * 二路插入排序算法 * 利用新的数组b[]来暂时存储对原数组a[]操作后的结果 * 首先将a[0]赋值给b[0] * 从i=1,开始至i&lt;length,遍历length-1次,每次处理a[i],看将其放到b[]中什么位置 * 首先判断,如果a[i]大于a[0],则将其放到b[0]之后(需要按照插入排序放,将b[0]后的数组看成递增数组) * 如果a[i]...

    qq_36370187的博客 366

    排序学习记录

    直接插入排序: 将待排序元素与已经排序好的序列进行比较插入其中。时间复杂度为O(n2) void InsertSort(SqList L, int n) { for (int i = 1; i < n; i++) { ElemType temp; if (L[i] < L[i - 1]) { temp = L[i]; for (int j = i; j...

    hongtaya的博客 178

    排序----插入排序,二路归并排序,堆排序,快速排序

    /* 堆:若将序列所存储的arr[1,n]看做是一棵完全二叉树的存储结构, 树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字 堆排序: 1.将要排序的数组创建为一个大根堆。大根堆的堆顶元素就是这个堆中最大的元素。 2.将大根堆的堆顶元素和无序区最后一个元素交换,并将无序区最后一个位置加入有序区,   然后将新的无序区调整为大根堆。重复操作,无序区在递减,有序

    cai0612123的专栏 762

    9种排序算法——堆排序,归并排序,插入排序,选择排序

    头文件如下 实现文件

    insprion的专栏 860
    上一篇: 排序系列 之 折半插入排序算法 —— Java实现
    下一篇: 白话经典算法系列之三 希尔排序的实现
    早起的虫儿灬
    博客等级 码龄10年 54粉丝 114原创
    评论
    成就一亿技术人!
    拼手气红包6.0元
    还能输入1000个字符
     
     条评论被折叠 查看
    添加红包

    请填写红包祝福语或标题

    个

    红包个数最小为10个

    元

    红包金额最低5元

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

    抵扣说明:

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

    余额充值