内部排序之四:归并排序和快速排序(含完整源码)

【数据结构与算法】内部排序之三:堆排序(含完整源码) 堆排序、快速排序、归并排序(下篇会写这两种排序算法)的平均时间复杂度都为O(n*logn)。要弄清楚堆排序,就要先了解下二叉堆这种数据结构。本文不打算完全讲述二叉堆的所有操作,而是着重讲述堆排序中要用到的操作。比如我们建堆的时候可以采用堆的插入操作(将元素插入到适当的位置,使新的序列仍符合堆的定义)将元素一个一个地插入到堆中,但其实我们完全没必要这么做,我们有执行操作更少的方法,后面你会看到,我们基本上只用到了堆的删除操作,更具体地说,应该是删除堆的根节点后,将剩余元素继续调整为堆的操作。先来看二叉堆的定义 阅读详情

前言   

    之所以把归并排序和快速排序放在一起探讨,很明显两者有一些相似之处:这两种排序算法都采用了分治的思想。下面来逐个分析其实现思想。

归并排序

    实现思想      

    归并的含义很明显就是将两个或者两个以上的有序表组合成一个新的有序表。归并排序中一般所用到的是2-路归并排序,即将含有n个元素的序列看成是n个有序的子序列,每个子序列的长度为1,而后两两合并,得到n/2个长度为2或1的有序子序列,再进行两两合并。。。直到最后由两个有序的子序列合并成为一个长度为n的有序序列。2-路归并的核心操作是将一维数组中前后相邻的两个有序序列归并为一个有序序列。

    下面一系列图展示了2-路归并排序的过程:

    原始无序序列:


    第一次需要对各相邻元素进行两两归并,归并后结果如下:


    第三次需要对上图中相邻色块的元素进行两两归并,归并后的结果如下:


    接下来便是最后一次两两归并了,归并后便的到了有序的序列,如下:


    第一次实现的代码   

    根据2-路归并操作的思想,站在节省辅助空间的角度上考虑,我写出的归并操作的代码如下:

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. /* 
  2. 将有序的arr[start...mid]和有序的arr[mid+1...end]归并为有序的arr[start...end] 
  3. */  
  4. void Merge(int *arr,int start,int mid,int end)  
  5. {  
  6.     int i = start;  
  7.     int j = mid+1;  
  8.     int k = 0;  
  9.     //brr为辅助数组,  
  10.     int *brr = (int *)malloc((end-start+1)*sizeof(int));  
  11.   
  12.     //比较两个有序序列中的元素,将较小的元素插入到brr中  
  13.     while(i<=mid && j<=end)  
  14.     {     
  15.         if(arr[i]<=arr[j])  
  16.             brr[k++] = arr[i++];  
  17.         else  
  18.             brr[k++] = arr[j++];  
  19.     }  
  20.   
  21.     //将arr序列中剩余的元素复制到brr中  
  22.     //这两个语句只可能执行其中一个  
  23.     while(i<=mid)  
  24.         brr[k++] = arr[i++];  
  25.     while(j<=end)  
  26.         brr[k++] = arr[j++];  
  27.   
  28.     //将brr中的元素复制到arr中,使arr[start...end]有序  
  29.     for(i=0;i<k;i++)  
  30.         arr[i+start] = brr[i];  
  31.   
  32.     //释放brr所占的内存,并将其置为空  
  33.     free(brr);      
  34.     brr = 0;  
  35. }  

    调用上面的函数,得到的归并排序的代码应该是这样的:

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. /* 
  2. 对arr[start...end]内的元素进行归并排序 
  3. 归并排序后的顺序为从小到大 
  4. */  
  5. void MSort(int *arr,int start,int end)  
  6. {  
  7.     if(start < end)  
  8.     {  
  9.         int mid = (start+end)/2;  
  10.         MSort(arr,start,mid);       //左边递归排序  
  11.         MSort(arr,mid+1,end);       //右边递归排序  
  12.         Merge(arr,start,mid,end);   //左右序列归并  
  13.     }  
  14. }  
  15. /* 
  16. 将该排序算法封装起来 
  17. */  
  18. void Merge_Sort(int *arr,int len)  
  19. {  
  20.     MSort(arr,0,len-1);  
  21. }  

    输入任意数组来测试,结果也是正确的。

    第二次实现的代码

    我看很多书上或者网上的例子给出的代码都要在Merge函数中多传入一个用来保存归并后有序序列的数组,并在MSort函数中另外声明一个临时数组,传给该参数,这样每次递归调用的时候都要在局部声明一个临时数组,很不好。正当我对自己的代码感觉良好时,看到了下面这段话:

    Merge例程是精妙的。如果对Merge的每个调用均局部声明一个临时数组(本人备注:即在MSort函数中声明),那么在任意时刻就可能有logN个临时数组处于活动期,这对于小内存的机器是致命的。另一方面,如果Merge例程动态分配并释放最小量临时内存,那么由malloc占用的时间会很多。严密测试指出,由于Merge位于MSort的最后一行,因此在任一时刻只需要一个临时数组活动,而且可以使用该临时数组的任意部分。(摘自Weiss数据结构与算法分析)

    很明显,我没有考虑malloc所带来的效率损耗,而且这里说得很好,由于Merge位于MSort的最后一行,因此每一次递归调用中只会存在一个临时数组,而不会有上一层递归中声明的临时数组(已经释放掉了)。

    为了避免递归使用malloc和free,我们还是用这种经典的实现方式的好,代码(一块贴上完整的测试代码)如下:

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. /******************************* 
  2.             归并排序 
  3. Author:兰亭风雨 Date:2014-02-28 
  4. Email:zyb_maodun@163.com 
  5. ********************************/  
  6. #include<stdio.h>  
  7. #include<stdlib.h>  
  8.   
  9. /* 
  10. 将有序的arr[start...mid]和有序的arr[mid+1...end]归并为有序的brr[0...end-start+1], 
  11. 而后再将brr[0...end-start+1]复制到arr[start...end],使arr[start...end]有序 
  12. */  
  13. void Merge(int *arr,int *brr,int start,int mid,int end)  
  14. {  
  15.     int i = start;  
  16.     int j = mid+1;  
  17.     int k = 0;  
  18.   
  19.     //比较两个有序序列中的元素,将较小的元素插入到brr中  
  20.     while(i<=mid && j<=end)  
  21.     {     
  22.         if(arr[i]<=arr[j])  
  23.             brr[k++] = arr[i++];  
  24.         else  
  25.             brr[k++] = arr[j++];  
  26.     }  
  27.   
  28.     //将arr序列中剩余的元素复制到brr中  
  29.     //这两个语句只可能执行其中一个  
  30.     while(i<=mid)  
  31.         brr[k++] = arr[i++];  
  32.     while(j<=end)  
  33.         brr[k++] = arr[j++];  
  34.   
  35.     //将brr中的元素复制到arr中,使arr[start...end]有序  
  36.     for(i=0;i<k;i++)  
  37.         arr[i+start] = brr[i];  
  38. }  
  39.   
  40. /* 
  41. 借助brr数组对arr[start...end]内的元素进行归并排序 
  42. 归并排序后的顺序为从小到大 
  43. */  
  44. void MSort(int *arr,int *brr,int start,int end)  
  45. {  
  46.     if(start < end)  
  47.     {  
  48.         int mid = (start+end)/2;  
  49.         MSort(arr,brr,start,mid);       //左边递归排序  
  50.         MSort(arr,brr,mid+1,end);       //右边递归排序  
  51.         Merge(arr,brr,start,mid,end);   //左右序列归并  
  52.     }  
  53. }  
  54. /* 
  55. 将该排序算法封装起来 
  56. */  
  57. void Merge_Sort(int *arr,int len)  
  58. {  
  59.     int *brr = (int *)malloc(len*sizeof(int));  
  60.     MSort(arr,brr,0,len-1);  
  61.     free(brr);  
  62.     brr = 0;  
  63. }  
  64.   
  65. int main()  
  66. {  
  67.     int num;  
  68.     printf("请输入排序的元素的个数:");  
  69.     scanf("%d",&num);  
  70.   
  71.     int i;  
  72.     int *arr = (int *)malloc(num*sizeof(int));  
  73.     printf("请依次输入这%d个元素(必须为整数):",num);  
  74.     for(i=0;i<num;i++)  
  75.         scanf("%d",arr+i);  
  76.   
  77.     printf("归并排序后的顺序:");  
  78.     Merge_Sort(arr,num);  
  79.     for(i=0;i<num;i++)  
  80.         printf("%d ",arr[i]);  
  81.     printf("\n");  
  82.   
  83.     free(arr);  
  84.     arr = 0;  
  85.     return 0;  
  86. }  

    小总结 

    归并排序的最好最坏和平均时间复杂度都是O(n*logn),但是需要额外的长度为n的辅助数组(每次递归调用前都会释放上次递归中传入到Merge函数的brr数组),因此空间复杂度为O(n),而不会因为栈的最大深度为O(logn)而积累至O(n*logn)。占用额外空间是归并排序不足的地方,但是它是几个高效排序算法(快速排序、堆排序、希尔排序)中唯一稳定的排序方法。


快速排序

     如名所示,快速排序是已知的平均时间复杂度均为O(n*logn)的几种排序算法中效率最高的一个,该算法之所以特别快,主要是由于非常精炼和高度优化的内部循环,它在最坏情况下的时间复杂度为O(n*n),但只要稍加努力(正确选择枢轴元素)就可以避免这种情形。

    本部分的重点在于对分治思想的理解和代码的书写,不打算过多地讨论枢轴元素的选择,因为这本身就不是一个简单的问题,笔者对此也没有什么研究,更不敢造次。先来看实现思想。

    实现思想

    快速排序的基本思想如下:

    1、从待排序列中任选一个元素作为枢轴;

    2、将序列中比枢轴大的元素全部放在枢轴的右边,比枢轴小的元素全部放在其左边;

    3、以枢轴为分界线,对其两边的两个子序列重复执行步骤1和2中的操作,直到最后每个子序列中只有一个元素。

    一趟快速排序(以排序后从小到大为例)的具体做法如下:

    附设两个元素指针low和high,初值分别为该序列的第一个元素的序号和最后一个元素的序号,设枢轴元素的值为val,则首先从high所指位置起向前搜索到第一个值小于val的元素,并将其和val互换位置,而后从low所指位置起向后搜索到第一个值大于val的元素,并将其和val交换位置,如此反复 ,直到low=high为止。

    我们上面说交换位置,只是为了便于理解,我们在前面几篇内部排序的博文中一直在强调,应尽量避免比较多的元素交换操作,因此下面的分析和代码的实现中,我们并不是采取交换操作,而是先将枢轴元素保存在val变量中,然后每次遇到需要交换的元素时,先将该元素赋给val所在的位置,而后再将该元素所在位置“挖空”,之后的每一次比较,就用需要交换的元素来填充上次“挖空”的位置,同时将交换过来的元素所在的位置再“挖空”,以等待下次填充。

    同样为了便于理解,我们以下面的序列为例来展示快速排序的思想。

    下图为无序序列的初始状态,我们选取val为第一个元素4,low和high分别指向4和5:


    进行1次比较之后(即从high开始遇到比val小的元素):


    进行2次比较之后(即从low开始遇到比val大的元素):


    进行3次比较之后(再次从high开始向左搜索):


    进行4次比较之后(再次从low开始向右搜索):


    进行5次比较之后(再次从high开始向左搜索),此时向左high向左移动一个位置后,出现low=high,第一趟排序结束,我们将val插入到此时被挖空的位置,也即low或high所指向的位置。因此第一趟排序后的结果如下:

    而后,我们分别对3、1、2和6、7、5进行同样操作,最终便可以得到如下有序序列:

  

    其中,加粗的元素为每趟比较时选取的枢轴元素,我们这里每次均选择子序列的第一个元素为枢轴。在这里,4为第一趟排序时选择的枢轴,3和6为第二趟排序时左右子序列分别选择的枢轴,第二趟排序后,数组的后半部分已经有序,前半部分虽然也有序了,但是根据定义,我们需要再选1作为枢轴,来对子序列{1,2}进行第三趟排序,这样最终便得到了该有序序列。

    实现代码

    很明显,实现快速排序要用到递归,我们根据以上思想,实现的代码如下(包含完整测试代码):

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. /******************************* 
  2.            快速排序 
  3. Author:兰亭风雨 Date:2014-02-28 
  4. Email:zyb_maodun@163.com 
  5. ********************************/  
  6. #include<stdio.h>  
  7. #include<stdlib.h>  
  8.   
  9. void Quick_Sort(int *,int,int);  
  10. int findPoss(int *,int,int);  
  11.   
  12. int main()  
  13. {  
  14.     int num;   
  15.     printf("请输入排序的元素的个数:");  
  16.     scanf("%d",&num);  
  17.   
  18.     int i;  
  19.     int *arr = (int *)malloc(num*sizeof(int));  
  20.     printf("请依次输入这%d个元素(必须为整数):",num);  
  21.     for(i=0;i<num;i++)  
  22.         scanf("%d",arr+i);  
  23.   
  24.     printf("快速排序后的顺序:");  
  25.     Quick_Sort(arr,0,num-1);  
  26.     for(i=0;i<num;i++)  
  27.         printf("%d ",arr[i]);  
  28.     printf("\n");  
  29.   
  30.     free(arr);  
  31.     arr = 0;  
  32.     return 0;  
  33. }  
  34.   
  35. /* 
  36. 快速排序函数,通过递归实现 
  37. */  
  38. void Quick_Sort(int *a,int low,int high)  
  39. {  
  40.     int pos;  
  41.   
  42.     if(low < high)  
  43.     {  
  44.        pos = findPoss(a,low,high);  
  45.        Quick_Sort(a,low,pos-1);     //左边子序列排序  
  46.        Quick_Sort(a,pos+1,high);    //右边子序列排序   
  47.     }  
  48. }  
  49.   
  50. /* 
  51. 该函数返回分割点数值所在的位置,a为待排序数组的首地址, 
  52. low刚开始表示排序范围内的第一个元素的位置,逐渐向右移动, 
  53. high刚开始表示排序范围内的最后一个位置,逐渐向左移动 
  54. */  
  55. int findPoss(int *a,int low,int high)  
  56. {  
  57.     int val = a[low];  
  58.     while(low < high)  
  59.     {  
  60.        while(low<high && a[high]>=val)  
  61.           high--;  
  62.        a[low] = a[high];  
  63.   
  64.        while(low<high && a[low]<=val)  
  65.           low++;  
  66.        a[high] = a[low];           
  67.     }  
  68.   
  69.     //最终low=high  
  70.     a[low] = val;  
  71.     return low;  
  72. }  

    小总结   

    通常,快速排序被认为在所有同数量级(平均时间复杂度均为O(n*logn))的排序方法中,平均性能最好。但是若初始记录已经基本有序,这样每次如果还选择第一个元素作为枢轴元素,则再通过枢轴划分子序列时,便会出现“一边倒”的情况,此时快速排序就完全成了冒泡排序,这便是最坏的情况,时间复杂度为O(n*n)。所以通常枢轴元素的选择一般基于“三者取中”的原则,即比较首元素、末元素、中间元素的值,取三者中中间大小的那个。经验表明,采取这种方法可以大大改善快速排序在最坏情况下的性能。

    快速排序需要一个栈来实现递归,很明显,如果序列中的元素是杂乱无章的,而且每次分割后的两个子序列的长度相近,则栈的最大深度为O(logn),而如果出现子序列“一边倒”的情况,则栈的最大深度为O(n)。因此就平均情况来看,快速排序的空间复杂度为O(logn)。


对字符串进行直接插入排序、堆排序、归并排序、快速排序实现以及性能分析 1) 排序 n 个元素,元素为随机生成的长为1..32的字符串(字符串均为英文小写字母),n的取值为:2^2,2^5,2^8,2^11,2^14,2^17; 2) 算法:直接插入排序,堆排序,归并排序,快速排序; 3) 字符串大小判断标准:首先按字符串长度进行排序(短字符串在前,长字符串在后)。然后对长度相同的字符串,按字母顺序进行排序; 4) 对结果进行性能分析。 阅读详情

相关推荐

TSP、MTSP问题遗传算法详细解读及python实现

写在前面 遗传算法是一种求解NPC问题的启发式算法,属于仿生进化算法族的一员。仿生进化算法是受生物行为启发而发明的智能优化算法,往往是人们发现某种生物的个体虽然行为较为简单,但生物集群通过某种原理却能表现出智能行为。于是不同的人研究不同的生物行为原理,受到启发而发明出新的仿生进化算法。比如免疫优化算法,蚁群算法,模拟退火算法等,这些算法以后也会简单介绍。 本文的主题是遗传算法,该算法也是受到生物行为启发。物竞天择,适者生存,优胜劣汰,是该优化算法的核心思想。笔者在业务中需要用到遗传算法求解TSP问题,但是网

weixin_47675950的博客 9306

【数据结构与算法】内部排序之四:归并排序和快速排序(含完整源码)

之所以把归并排序和快速排序放在一起探讨,很明显两者有一些相似之处:这两种排序算法都采用了分治的思想。下面来逐个分析其实现思想。 归并排序 实现思想 归并的含义很明显就是将两个或者两个以上的有序表组合成一个新的有序表。归并排序中一般所用到的是2-路归并排序,即将含有n个元素的序列看成是n个有序的子序列,每个子序列的长度为1,而后两两合并,得到n/2个长度为2或1的有序子序列,再进行两两合并。。。直到最后由两个有序的子序列合并成为一个长度为n的有序序列。2-路归并的核心操作是将一维数

兰亭风雨的专栏 1万+

京东联盟h5st(3.1)加密参数逆向实战与反爬对抗策略

本文详细解析了京东联盟h5st(3.1)加密参数的逆向分析与实战破解过程。通过接口分析定位关键加密函数,拆解h5st结构并还原其基于SHA256和HMAC-SHA256的加密逻辑,最终使用Python集成JavaScript环境成功复现加密算法,并分享了应对反爬的频率限制、IP封禁及算法升级等对抗策略。

weixin_29246195的博客 1740

C 语言实现常见排序算法:快速排序与归并排序

快速排序和归并排序都是非常高效的排序算法,平均时间复杂度都为 O (n log n)。快速排序通常在实际应用中表现出色,而归并排序则在处理大规模数据或对稳定性有要求的场景中更具优势。希望通过本文的代码示例,读者能更好地理解和掌握这两种重要的排序算法。

qq_66192333的博客 421

手把手复现论文:SVPWM过调制I区与II区算法仿真(附MATLAB源码)

本文详细介绍了SVPWM过调制I区与II区算法的MATLAB仿真实现,从理论推导到Simulink建模逐步解析。通过源码示例展示幅值补偿和六边形跟踪等关键技术,帮助电力电子研究者掌握过调制算法的核心实现方法,适用于电机控制、变频器等工业应用场景。

weixin_28739079的博客 532

【electron】- 从零到一:在electron-vite项目中集成better-sqlite3的工程化实践

本文详细介绍了在electron-vite项目中集成better-sqlite3数据库的完整工程化实践。针对原生模块的编译挑战,提供了从环境配置、路径规划、服务封装到IPC通信的解决方案,并重点解决了开发与生产环境的数据库路径分离及打包部署等核心问题,帮助开发者构建稳定高效的Electron桌面应用数据层。

weixin_29306571的博客 207

快速排序和归并排序代码

python实现快速排序和归并排序

tianxinyiru的博客 234

Wonderware Intouch 2014R2 SP1 安装教程

下载Wonderware System Platform 2014R2 SP1 and Intouch 2014R2 SP1的安装压缩包,如下 软件的下载连接地址如下: https://pan.baidu.com/s/1a2GnI_nfT3vK1l49B94FIQ, 提取码:6ec6 或者直接微信扫描下面的二维码 管理员运行下面的setup.exe可执行程序, 进入安装,选择Product Based Selection, 自定义选择需要安装的程序,如下: 普通的Into

工控先生 3万+

C语言实现归并排序、堆排序、快速排序和冒泡排序

【代码】C语言实现归并排序、堆排序、快速排序和冒泡排序。

m0_59949484的博客 267

landsat8数据下载教程

下载landsat数据教程

weixin_44001203的博客 1万+

分区补光与ISP图像调节技术

在安防监控场景中,逆光、强光、明暗不均(如门口 / 窗边的 “阴阳脸” 画面)是导致图像细节丢失的核心问题。分区补光技术通过对画面不同亮度区域精准补光,解决 “局部过曝 / 欠曝” 难题;ISP(图像信号处理器)图像调节技术则通过算法优化,提升画面色彩、对比度与细节。二者协同可实现 “硬件补光 + 算法优化” 的双重增强,是低功耗摄像机实现高清画质的关键技术组合。分区补光与 ISP 图像调节技术:原理、协同方案及安防监控应用案例。一、核心技术原理解析。

AIoT深度探索者 | 嵌入式系统架构师 深耕物联网(IoT)与人工智能(AI)融合技术,聚焦​​边缘计算、图像开发、低功耗通信协议​​,致力于智能硬件,关注我获取最新技术文章信息与海量资源~ 733

排序算法的python实现及算法分析——归并排序(merge sort)和快速排序(quick sort)

5 归并排序 归并排序的思路是将数据表持续分裂成为两半,分别对两半进行归并排序,然后在合并,其过程为递归算法。每个步骤为: 归并排序实例 python实现源码 ## 归并算法 def merge_sort (lst): if len(lst)<=1: #递归结束条件 return lst #分解问题,并递归调用 middle=len(lst)//2 left=merge_sort(lst[:middle]) right=merge_sor

cy15625010944的博客 711

手把手教你RK3568 MIPI屏驱动适配,纯干货!

RK3568 作为一款高性能的多媒体处理器,在嵌入式领域中备受瞩目。它采用了先进的 22nm 制程工艺,搭载四核 Cortex-A55 处理器,这种架构为芯片提供了高效的功耗比,使其在运行各种复杂任务时,既能保证性能,又能有效控制功耗。在实际应用中,无论是多任务处理还是运行大型应用程序,RK3568 都能凭借其四核 Cortex-A55 处理器,实现流畅的操作体验,满足智能设备对高性能和低功耗的需求。

远程部署调试 运行安装 项目调试 二次开发 项目技术新 持续迭代 部分源码免费分享 4073

第十九篇:内部排序之四:归并排序和快速排序(含完整源码)

前言        之所以把归并排序和快速排序放在一起探讨,很明显两者有一些相似之处:这两种排序算法都采用了分治的思想。下面来逐个分析其实现思想。 归并排序     实现思想           归并的含义很明显就是将两个或者两个以上的有序表组合成一个新的有序表。归并排序中一般所用到的是2-路归并排序,即将含有n个元素的序列看成是n个有序的子序列,每个子序列的长度为1,而后两两合并,得

u012426327的专栏 399

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

单向链表排序:快速排序和归并排序

归并排序改变链接 快速排序改变链接 快速排序改变节点值 所有源码和测试函数 对单向链表的排序有2种形式,只改变节点的值 和 只改变链接// 节点 struct ListNode { int val; ListNode* next; ListNode(int v, ListNode* n = NULL) { val = v; next = n;

quinn的专栏 6212

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

【初阶数据结构与算法】排序算法总结篇(每个小节后面有源码)(直接插入、希尔、选择、堆、冒泡、快速、归并、计数以及非递归快速、归并排序)

本篇内容将从稳定性与复杂度等角度分析排序算法,列出它们的特点、优点以及缺点,希望大家有所收获,如果想更加细节地学习可以去看我之前写的各种排序算法的文章。

hdxbufcbjuhg的博客 5812

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

八大内部排序+外部排序

排序划分 内部排序 1.直接插入排序 基本思想 通常人们整理桥牌的方法是一张一张的来,将每一张牌插入到其他已经有序的牌中的适当位置。在计算机的实现中,为了要给插入的元素腾出空间,我们需要将其余所有元素在插入之前都向右移动一位。 算法描述 一般来说,插入排序采用in-place在数组上实现.具体算法如下: 1.从第一个元素开始,该元素可以认为已经被排序. 2.取出下一个元素,在已经排序的元素序列中...

炎溟墨的博客 6152

【Java数据结构与算法】快速回忆十大排序 + 使用插入排序、归并排序、快速排序对链表进行排序

Java中Arrays.sort()中用的排序。快速掌握十大排序:冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序。 链表排序:插入排序、快速排序、归并排序

ly甲烷的博客 728

python排序算法速度比较:快速排序,归并排序,冒泡排序

提示:写完文章后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录 系列文章目录 前言 一、pandas是什么? 二、使用步骤 1.引入库 2.读入数据 总结 前言 原理就不在这里说了,好多大神肯定比我这个初学者讲的好很多,推荐去B站看视频讲解,跟着手敲代码 为什么选这三个排序呢? 首先快排是必须掌握的 看看快排在最坏的情况下(O(n²)),且不使用辅助空间,与冒泡(O(n²))的比较 由于快排是不稳定的排序算法,且平均时间复杂度为O(nlog...

人生苦短 2864

【算法】排序详解(快速排序,堆排序,归并排序,插入排序,希尔排序,选择排序,冒泡排序)

详细介绍插入排序,希尔排序,选择排序,堆排序,冒泡排序,快速排序,归并排序,均有给出源码和图片非常详细!!!

2301_80035594的博客 6982

归并排序与快速排序

分治法分治法的思想:将原问题分解为几个规模较小但类似原问题的子问题,递归的求解这些子问题,然后合并这些子问题的解来建立原问题的解。及分而治之分治模式在每层递归时都有三个步骤: 分解原问题为若干子问题,这些子问题是原问题规模较小的实例 解决这些子问题,递归地求解各子问题。然而,若子问题的规模足够小,则直接求解。 合并这些子问题的解成原问题的解。归并排序归并排序算法完全遵循分治模式。只管上其操作如

david_liang 2037

Leetcode21.+Leetcode75. 归并排序和快速排序的实现

归并排序 快速排序

obrcnh的博客 3671

【数据结构】十大排序

打开算法大门,从排序开始

英雄哪里出来 7万+

[排序算法]归并排序、快速排序

上一篇:[排序算法]冒泡排序、插入排序、选择排序 文章目录1. 归并排序1) 时间复杂度2) 归并排序不是原地算法3) 归并排序是稳定算法2. 快速排序1) 时间复杂度2) 快速排序是原地算法3) 快速排序不是稳定算法3. 总结 1. 归并排序 // 归并排序使用了分治的思想,首先分,缩小数据规模,然后再将部分结果合并起来 public void mergeSort(int[] a) { ...

sougou_1323的博客 754
上一篇: TNS-12535:TNS:操作超时
下一篇: 插入排序
天天向上zb
博客等级 码龄16年 34粉丝 43原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值