0
0

排序（一）——简单排序：插入排序 && 冒泡排序

相关文章：

  • 排序（二）：分而治之——快速排序 && 归并排序
  • 排序（三）：谁主沉浮——堆与堆排序

leetcode：https://leetcode-cn.com/problems/sort-an-array/

插入排序

过程

插入排序的过程分为两步：

  • 首先和当前位置的前一个元素进行比较，如果前一个元素比当前元素大，则后续进行调整，将前面的大元素不断向后移动，并找到合适的位置将当前元素插入进去；
  • 如果发现前一个元素比当前元素小，则不会进行调整，默认前面的元素已经有序。

示意图如下：
请添加图片描述
插入排序的特点是：基于比较、数据移动完成排序，一次比较操作后不发生数据移动或仅仅交换一对相邻的数据元素。

代码

  1. classSolution{publicint[]sortArray(int[] nums){int i,j;for(i =1; i < nums.length; i++){if(nums[i]< nums[i-1]){int temp = nums[i];
  2.                 nums[i]= nums[i-1];for(j = i-2; j >=0&& nums[j]> temp; j--){
  3.                     nums[j+1]= nums[j];}
  4.                 nums[j+1]= temp;}}return nums;}}

时间复杂度

逆序：对于数对 

  1.     (
  2.    
  3.    
  4.     π
  5.    
  6.    
  7.     (
  8.    
  9.    
  10.     i
  11.    
  12.    
  13.     )
  14.    
  15.    
  16.     ,
  17.    
  18.    
  19.     π
  20.    
  21.    
  22.     (
  23.    
  24.    
  25.     j
  26.    
  27.    
  28.     )
  29.    
  30.    
  31.     )
  32.    
  33.   
  34.   
  35.    (\pi(i), \pi(j))
  36.   
  37.  
  38. (π(i),π(j)) ，有 
  40.  
  41.   
  42.    
  43.     j
  44.    
  45.    
  46.     <
  47.    
  48.    
  49.     j
  50.    
  51.   
  52.   
  53.    j < j
  54.   
  55.  
  56. j<j 而 
  58.  
  59.   
  60.    
  61.     π
  62.    
  63.    
  64.     (
  65.    
  66.    
  67.     i
  68.    
  69.    
  70.     )
  71.    
  72.    
  73.     >
  74.    
  75.    
  76.     π
  77.    
  78.    
  79.     (
  80.    
  81.    
  82.     j
  83.    
  84.    
  85.     )
  86.    
  87.   
  88.   
  89.    \pi(i)>\pi(j)
  90.   
  91.  
  92. π(i)>π(j) 。

插入排序的实质是消除数对的逆序，一个含有 n 个元素的序列有 

  1.       n
  2.      
  3.      
  4.       (
  5.      
  6.      
  7.       n
  8.      
  9.      
  10.       −
  11.      
  12.      
  13.       1
  14.      
  15.      
  16.       )
  17.      
  18.     
  19.     
  20.      2
  21.     
  22.    
  23.   
  24.   
  25.    \frac{n(n-1)}{2}
  26.   
  27.  
  28. 2n(n−1)​ 个数对，则最多有 
  30.  
  31.   
  32.    
  33.     
  34.      
  35.       n
  36.      
  37.      
  38.       (
  39.      
  40.      
  41.       n
  42.      
  43.      
  44.       −
  45.      
  46.      
  47.       1
  48.      
  49.      
  50.       )
  51.      
  52.     
  53.     
  54.      2
  55.     
  56.    
  57.   
  58.   
  59.    \frac{n(n-1)}{2}
  60.   
  61.  
  62. 2n(n−1)​ 个逆序，平均有 
  64.  
  65.   
  66.    
  67.     
  68.      
  69.       n
  70.      
  71.      
  72.       (
  73.      
  74.      
  75.       n
  76.      
  77.      
  78.       −
  79.      
  80.      
  81.       1
  82.      
  83.      
  84.       )
  85.      
  86.     
  87.     
  88.      4
  89.     
  90.    
  91.   
  92.   
  93.    \frac{n(n-1)}{4}
  94.   
  95.  
  96. 4n(n−1)​ 个逆序，而插入排序在一次数对比较之后最后消除一对逆序。

基于此，分析插入排序的最好情况 

  1.     B
  2.    
  3.    
  4.     (
  5.    
  6.    
  7.     n
  8.    
  9.    
  10.     )
  11.    
  12.   
  13.   
  14.    B(n)
  15.   
  16.  
  17. B(n)，平均情况 
  19.  
  20.   
  21.    
  22.     A
  23.    
  24.    
  25.     (
  26.    
  27.    
  28.     n
  29.    
  30.    
  31.     )
  32.    
  33.   
  34.   
  35.    A(n)
  36.   
  37.  
  38. A(n) 和最坏情况 
  40.  
  41.   
  42.    
  43.     W
  44.    
  45.    
  46.     (
  47.    
  48.    
  49.     n
  50.    
  51.    
  52.     )
  53.    
  54.   
  55.   
  56.    W(n)
  57.   
  58.  
  59. W(n)。
  • 最好情况：元素升序有序。那么我们只需要进行 n-1 次元素比较，0 次元素移动即可， B ( n ) ∈ O ( n ) B(n) \in O(n) B(n)∈O(n)。
  • 最坏情况：元素降序有序。那么我们需要进行 n ( n − 1 ) 2 \frac{n(n-1)}{2} 2n(n−1)​ 次元素比较，同样次数的元素移动， W ( n ) ∈ O ( n 2 ) W(n) \displaystyle \in O(n^2) W(n)∈O(n2)。
  • 平均时间复杂度：平均比较 n ( n − 1 ) 4 \frac{n(n-1)}{4} 4n(n−1)​ 次， A ( n ) ∈ O ( n 2 ) A(n) \displaystyle \in O(n^2) A(n)∈O(n2)。

代码优化

定理：任何一个基于关键字的比较且每一次比较最多消除一个逆序的排序算法，最坏的情况下至少比较 

  1.       n
  2.      
  3.      
  4.       (
  5.      
  6.      
  7.       n
  8.      
  9.      
  10.       −
  11.      
  12.      
  13.       1
  14.      
  15.      
  16.       )
  17.      
  18.     
  19.     
  20.      2
  21.     
  22.    
  23.   
  24.   
  25.    \frac{n(n-1)}{2}
  26.   
  27.  
  28. 2n(n−1)​ 次，平均情况至少比较 
  30.  
  31.   
  32.    
  33.     
  34.      
  35.       n
  36.      
  37.      
  38.       (
  39.      
  40.      
  41.       n
  42.      
  43.      
  44.       −
  45.      
  46.      
  47.       1
  48.      
  49.      
  50.       )
  51.      
  52.     
  53.     
  54.      4
  55.     
  56.    
  57.   
  58.   
  59.    \frac{n(n-1)}{4}
  60.   
  61.  
  62. 4n(n−1)​ 次。无法从 
  64.  
  65.   
  66.    
  67.     O
  68.    
  69.    
  70.     (
  71.    
  72.    
  73.     
  74.      n
  75.     
  76.     
  77.      2
  78.     
  79.    
  80.    
  81.     )
  82.    
  83.   
  84.   
  85.    O(n^2)
  86.   
  87.  
  88. O(n2) 的复杂度降低。

冒泡排序

过程

  • 将待排序的数据元素的关键字顺次两两比较，若为逆序则将两个数据元素交换
  • 将待排序的数据元素照此方法从头到尾处理一遍称作一趟起泡排序，它将关键字值最大的数据元素交换到排序的最终位置。
  • 对含 n 个记录的文件排序最多需要 n-1 趟冒泡排序。请添加图片描述

代码

  1. classSolution{publicint[]sortArray(int[] nums){for(int i =0; i < nums.length; i++){for(int j =0; j < nums.length-i-1; j++){if(nums[j]> nums[j+1]){int temp = nums[j+1];
  2.                     nums[j+1]= nums[j];
  3.                     nums[j]= temp;}}}return nums;}}

时间复杂度

  • 最坏情况：序列是逆序，需要比较的次数为 n(n-1)/2，则对应时间复杂度为 $ W(n) \displaystyle \in O(n^2)$ 。
  • 最好情况：序列已经是升序有序序列，则进行一次比较即可，第一次比较发现没有发生数据移动，则排序结束，比较次数为 n - 1 次，则时间复杂度为 B ( n ) ∈ O ( n 2 ) ) B(n) \displaystyle \in O(n^2)) B(n)∈O(n2)) 。
  • 平均情况： A ( n ) ∈ O ( n 2 ) ) A(n) \displaystyle \in O(n^2)) A(n)∈O(n2))

代码优化

优化1：记下最后一次交换的位置，后边没有交换，必然是有序的，然后下一次排序从第一个比较到上次记录的位置结束即可。同时引入布尔变量 sorted 作为标记，如果在一趟排序中没有交换元素，说明这组数据已经有序，不用再继续下去。

  1. classSolution{publicint[]sortArray(int[] nums){int temp =0;intLastExchangeIndex=0;//上一次交换位置int border = nums.length-1;//无序列表边界for(int i =0; i < nums.length; i++){boolean sorted =true;for(int j =0; j < border; j++){if(nums[j]> nums[j+1]){
  2.                     temp = nums[j+1];
  3.                     nums[j+1]= nums[j];
  4.                     nums[j]= temp;LastExchangeIndex= j;
  5.                     sorted =false;}}if(sorted)break;
  6.             border =LastExchangeIndex;}return nums;}}

优化2：双边界冒泡排序，见《计算机算法——设计与分析导论》习题4.5。以序列(2,3,4,5,1) 为例，在普通冒泡排序下，需要盲目比较左侧有序子列，引入左侧边界解决这一问题：找到首个交换位置 pos，则下一趟冒泡排序的起始位置 border_left = pos - 1 or 0。

  1. classSolution{publicint[]sortArray(int[] nums){//双边界冒泡排序intFirstExchangeIndex=0;intLastExchangeIndex=0;int border_left =0;int border_right = nums.length -1;for(int i =0; i < nums.length; i++){boolean sorted_left =true;boolean sorted =true;for(int j = border_left; j < border_right; j++){if(nums[j]> nums[j+1]){//记录首个交换的位置if(sorted_left){
  2.                         border_left = j-1>=0? j-1:0;//左边界更新
  3.                         sorted_left =false;}int temp = nums[j];
  4.                     nums[j]= nums[j+1];
  5.                     nums[j+1]= temp;
  6.                     sorted =false;LastExchangeIndex= j;}}if(sorted)break;
  7.             border_right =LastExchangeIndex;}return nums;}}

优化3：鸡尾酒排序，又称双向冒泡排序、搅拌排序。排序过程像钟摆一样，奇数轮从左到右，偶数轮从右到左。示意图如下：
请添加图片描述

鸡尾酒排序适用于基本有序的序列。还以序列(2,3,4,5,1)为例，鸡尾酒排序只需要访问一次序列就可以完成排序，但如果使用冒泡排序则需要四次。在乱数序列的状态下，鸡尾酒排序与冒泡排序的效率相当（都为 

  1.     O
  2.    
  3.    
  4.     (
  5.    
  6.    
  7.     
  8.      n
  9.     
  10.     
  11.      2
  12.     
  13.    
  14.    
  15.     )
  16.    
  17.   
  18.   
  19.    O(n^2)
  20.   
  21.  
  22. O(n2) ）。缺点是代码量较大。
  • 最差时间复杂度 O ( n 2 ) O(n^2) O(n2)
  • 最优时间复杂度 O ( n ) O(n) O(n)
  • 平均时间复杂度 O ( n 2 ) O(n^2) O(n2)
  1. classSolution{publicint[]sortArray(int[] nums){int border_right = nums.length -1;int border_left =0;intLastExchangeIndex_right=0;intLastExchangeIndex_left=0;for(int i =0; i < nums.length/2; i++){//正向boolean sorted =true;for(int j =0; j < border_right; j++){if(nums[j]> nums[j+1]){int temp = nums[j];
  2.                     nums[j]= nums[j+1];
  3.                     nums[j+1]= temp;LastExchangeIndex_right= j;
  4.                     sorted =false;}}if(sorted)break;
  5.             border_right =LastExchangeIndex_right;//反向
  6.             sorted =true;for(int j = nums.length-1-i; j > border_left; j--){if(nums[j]< nums[j-1]){int temp = nums[j];
  7.                     nums[j]= nums[j-1];
  8.                     nums[j-1]= temp;LastExchangeIndex_left= j;
  9.                     sorted =false;}}if(sorted)break;
  10.             border_left =LastExchangeIndex_left;}return nums;}}
标签： 排序算法 算法 数据结构
本文转载自: https://blog.csdn.net/qq_43080609/article/details/122292537
版权归原作者 无限之阿尔法 所有， 如有侵权，请联系我们删除。
登录后发布评论

“排序（一）&mdash;&mdash;简单排序：插入排序 &amp;&amp; 冒泡排序”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？