devbox
正经夜光杯
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

通过Java实现插入排序（直接插入，希尔）与选择排序（直接选择，堆排）

作者：正经夜光杯 | 2024-08-03 07:51:28

赞

踩

通过Java实现插入排序（直接插入，希尔）与选择排序（直接选择，堆排）

目录

（一）插入排序

1.直接插入排序

（1）核心思想：

 （2）代码实现（以从小到大排序为例）：

（3）代码分析：

2.希尔排序（缩小增量排序）

（1）核心思想：

（2）代码实现（以从小到大排序为例）： 

（3）代码分析：

（二）选择排序

1.直接选择排序

（1）核心思想：

（2）代码实现（以从小到大排序为例）：

（3）代码分析：

2.堆排序

（1）核心思想：

（2）代码实现（以从小到大排序为例）：

 （3）代码分析：

（三）示例以及各算法耗时参考

1.代码结构

2.程序源码

（1）Sort类：

（2）Test类：

3.测试结果

 ​编辑

（一）插入排序

1.直接插入排序

（1）核心思想：

直接插入排序，顾名思义，即将非有序部分的元素按大小规律逐个插入到有序的部分中，最终使得整体有序。举个简单的例子：当我们在玩扑克牌逐个摸牌时，就会将新牌插入到原来有序的手牌中，此时其实就用到了插入排序的思想。

 （2）代码实现（以从小到大排序为例）：

  1.     public static void insertSort(int[] array){
  2.         //遍历非有序部分数组
  3.         for(int i=1;i<array.length;i++){
  4.             //取出非有序部分的第一个元素并向前逐个比对
  5.             int tmp=array[i];
  6.             int j=i-1;
  7.             for(;j>=0;j--){
  8.                 if(tmp<array[j]){
  9.                     //若该元素比前面某元素小，则某元素后移，该元素继续向前比对
  10.                     array[j+1]=array[j];
  11.                 }else{
  12.                     //相反若该元素比前面某元素大，则退出循环
  13.                     break;
  14.                 }
  15.                 //内层循环结束说明已经为该元素找到合适位置，直接插入即可
  16.                 array[j+1]=tmp;
  17.             }
  18.         }
  19.     }

（3）代码分析：

1）时间复杂度：最好情况下（数组本身有序）：O(N)；最坏情况下（数组本身逆序）：O(N^2)。

2）空间复杂度：O（1）（即并未申请额外内存）。

3）稳定性：稳定。

由上可知对于越有序的数组，使用直接插入排序更有优势。

2.希尔排序（缩小增量排序）

（1）核心思想：

希尔排序，又称为缩小增量排序，其本质为直接插入排序的优化形式，在直接插入排序的基础上采取了分治（即分而治之，分组考虑）的思想：通过设定元素下标间隔增量gap来将一组元素分为多组，分别进行直接插入排序，将每个组排完序后将gap减小重复上述过程，直到gap为1，上述全过程整租元素都在不断趋于有序，最终实现排序效果。

例如：数组元素为10时且设定第一次gap为5的情况：

（2）代码实现（以从小到大排序为例）： 

  1.  
  2.     //实现希尔排序方法
  3.     public static void shellSort(int[] array){
  4.         //设定间隔增量gap
  5.         int gap=array.length;
  6.         while (gap > 1) {
  7.             //每次循环缩小间隔增量
  8.             gap/=2;
  9.             //以间隔增量对数组进行分组插入排序
  10.             shellSortChild(array,gap);
  11.         }
  12.     }
  13.  
  14.     //实现希尔排序的底层方法
  15.     private static void shellSortChild(int[]array,int gap){
  16.         //遍历非有序部分数组，i++表示对每组进行交替排序
  17.         for(int i=gap;i<array.length;i++){
  18.             //取出非有序部分的第一个元素并向前逐个比对
  19.             int tmp=array[i];
  20.             int j=i-gap;
  21.             for(;j>=0;j-=gap){
  22.                 if(tmp<array[j]){
  23.                     //若该元素比前面某元素小，则某元素后移，该元素继续向前比对
  24.                     array[j+gap]=array[j];
  25.                 }else{
  26.                     //相反若该元素比前面某元素大，则退出循环
  27.                     break;
  28.                 }
  29.                 //内层循环结束说明已经为该元素找到合适位置，直接插入即可
  30.                 array[j+gap]=tmp;
  31.             }
  32.         }
  33.     }

（3）代码分析：

1）时间复杂度：目前无法严格证明，原因是该算法根据gap的取法不同而不同（本题中gap取法为二分法，即不断除以二），并且当gap较大时每组遍历次数较少，gap较小时整体又更有序，无法进行严格计算，但有学者通过大量实验证明希尔排序的时间复杂度应该介于N^1.25~1.6N^1.25之间，可以估计为O(N^1.3)。

2）空间复杂度：O（1）（即并未申请额外内存）。

3）稳定性：不稳定。

联系直接插入排序可知，希尔排序可以克服传统直接插入排序在完全逆序情况下时间复杂度过高的劣势。

（二）选择排序

1.直接选择排序

（1）核心思想：

直接选择排序，顾名思义，即每一次从非有序部分的元素中选出最小（或最大）的一个元素，存放在非有序部分的起始位置，直到全部非有序部分元素全部排完，此时整组元素有序。

（2）代码实现（以从小到大排序为例）：

  1.     //实现直接选择排序
  2.     public static void selectSort(int[]array){
  3.         //遍历非有序部分数组
  4.         for(int i=0;i< array.length;i++){
  5.             //默认最小值下标为起始下标
  6.             int minIndex=i;
  7.             //遍历剩余部分寻找最小值下标
  8.             for(int j=i+1;j< array.length;j++){
  9.                 if(array[j]<array[i]){
  10.                     minIndex=j;
  11.                 }
  12.             }
  13.             //循环结束证明已经找到最小值下标，与非有序部分起始位置交换
  14.             int tmp=array[minIndex];
  15.             array[minIndex]=array[i];
  16.             array[i]=tmp;
  17.         }
  18.     }

（3）代码分析：

1）时间复杂度：无论何时均为O(N^2)。

2）空间复杂度：O（1）（即并未申请额外内存）。

3）稳定性：不稳定。

2.堆排序

（1）核心思想：

利用堆的优先级特性，升序排列建大堆，降序排列建小堆，每次将堆顶元素和未排序堆尾元素互换后进行向上调整（这样堆尾元素一定是当前堆的最值），最终整个堆有序。（思路类似于直接选择排序或者冒泡排序，即每次都将未排序的部分中的最值放于末尾，如此最终整个数组有序）。

（2）代码实现（以从小到大排序为例）：

  1.     //实现堆排序
  2.  
  3.     //创建一个大根堆的方法
  4.     public static void createMaxHeap(int[] array){
  5.         //从最后一棵子树倒序调整
  6.         for(int parent=((array.length-1-1)/2);parent>=0;parent--){
  7.             //调用向下调整的底层方法
  8.             maxSiftDown(array,parent,array.length-1);
  9.         }
  10.     }
  11.  
  12.     //创建大根堆时调用到的向下调整的底层方法
  13.     private static void maxSiftDown(int[]array,int parent,int end){
  14.         //默认子女中的最大值为左子女
  15.         int child=2*parent+1;
  16.         while(child<end){
  17.             //判断右子女是否为二者中最大值
  18.             if(child+1<end){
  19.                 if(array[child]<array[child+1]){
  20.                     child++;
  21.                 }
  22.             }
  23.             if(array[parent]<array[child]){
  24.                 //子女节点中最大值大于双亲则进行交换调整
  25.                 int temp=array[parent];
  26.                 array[parent]=array[child];
  27.                 array[child]=temp;
  28.                 //向下迭代
  29.                 parent=child;
  30.                 child=2*parent+1;
  31.             }else{
  32.                 //子女节点中最大值小于双亲说明该树已经为大根堆，无需向下调整，直接中断即可
  33.                 break;
  34.             }
  35.         }
  36.     }
  37.  
  38.     //利用创建的大根堆实现堆排序
  39.     public static void heapSort(int[]array){
  40.         createMaxHeap(array);
  41.         int end= array.length-1;
  42.         while(end>0){
  43.             //将堆顶元素和堆尾元素交换
  44.             int temp=array[end];
  45.             array[end]=array[0];
  46.             array[0]=temp;
  47.             //利用大根堆向下调整的方法
  48.             maxSiftDown(array,0,end);
  49.             end--;
  50.         }
  51.     }

（注：堆的创建，向上调整部分具体思路及讲解可见本人博客：通过Java模拟实现堆（大根堆与小根堆）及其相关操作http://t.csdnimg.cn/JZlWL ）

 （3）代码分析：

1）时间复杂度：O(N^log N)。

2）空间复杂度：O（1）（即并未申请额外内存，注意建堆也是在原数组上进行操作的）。

3）稳定性：不稳定。

（三）示例以及各算法耗时参考

1.代码结构

1. Sort类：内部实现直接选择排序，希尔排序，直接插入排序，堆排序相关方法（即上文实现的四种算法）

2.Test类：实现创建顺序数组，逆序数组，随机数组的方法（用来测试四种算法）以及测量四种算法耗时的方法，并在main方法中进行示例演示。

2.程序源码

（1）Sort类：

  1. public class Sort {
  2.     //实现直接插入排序方法
  3.     public static void insertSort(int[] array){
  4.         //遍历非有序部分数组
  5.         for(int i=1;i<array.length;i++){
  6.             //取出非有序部分的第一个元素并向前逐个比对
  7.             int tmp=array[i];
  8.             int j=i-1;
  9.             for(;j>=0;j--){
  10.                 if(tmp<array[j]){
  11.                     //若该元素比前面某元素小，则某元素后移，该元素继续向前比对
  12.                     array[j+1]=array[j];
  13.                 }else{
  14.                     //相反若该元素比前面某元素大，则退出循环
  15.                     break;
  16.                 }
  17.                 //内层循环结束说明已经为该元素找到合适位置，直接插入即可
  18.                 array[j+1]=tmp;
  19.             }
  20.         }
  21.     }
  22.  
  23.     //实现希尔排序方法
  24.     public static void shellSort(int[] array){
  25.         //设定间隔增量gap
  26.         int gap=array.length;
  27.         while (gap > 1) {
  28.             //每次循环缩小间隔增量
  29.             gap/=2;
  30.             //以间隔增量对数组进行分组插入排序
  31.             shellSortChild(array,gap);
  32.         }
  33.     }
  34.  
  35.     //实现希尔排序的底层方法
  36.     private static void shellSortChild(int[]array,int gap){
  37.         //遍历非有序部分数组，i++表示对每组进行交替排序
  38.         for(int i=gap;i<array.length;i++){
  39.             //取出非有序部分的第一个元素并向前逐个比对
  40.             int tmp=array[i];
  41.             int j=i-gap;
  42.             for(;j>=0;j-=gap){
  43.                 if(tmp<array[j]){
  44.                     //若该元素比前面某元素小，则某元素后移，该元素继续向前比对
  45.                     array[j+gap]=array[j];
  46.                 }else{
  47.                     //相反若该元素比前面某元素大，则退出循环
  48.                     break;
  49.                 }
  50.                 //内层循环结束说明已经为该元素找到合适位置，直接插入即可
  51.                 array[j+gap]=tmp;
  52.             }
  53.         }
  54.     }
  55.  
  56.     //实现直接选择排序
  57.     public static void selectSort(int[]array){
  58.         //遍历非有序部分数组
  59.         for(int i=0;i< array.length;i++){
  60.             //默认最小值下标为起始下标
  61.             int minIndex=i;
  62.             //遍历剩余部分寻找最小值下标
  63.             for(int j=i+1;j< array.length;j++){
  64.                 if(array[j]<array[i]){
  65.                     minIndex=j;
  66.                 }
  67.             }
  68.             //循环结束证明已经找到最小值下标，与非有序部分起始位置交换
  69.             int tmp=array[minIndex];
  70.             array[minIndex]=array[i];
  71.             array[i]=tmp;
  72.         }
  73.     }
  74.  
  75.     //实现堆排序
  76.  
  77.     //创建一个大根堆的方法
  78.     public static void createMaxHeap(int[] array){
  79.         //从最后一棵子树倒序调整
  80.         for(int parent=((array.length-1-1)/2);parent>=0;parent--){
  81.             //调用向下调整的底层方法
  82.             maxSiftDown(array,parent,array.length-1);
  83.         }
  84.     }
  85.  
  86.     //创建大根堆时调用到的向下调整的底层方法
  87.     private static void maxSiftDown(int[]array,int parent,int end){
  88.         //默认子女中的最大值为左子女
  89.         int child=2*parent+1;
  90.         while(child<end){
  91.             //判断右子女是否为二者中最大值
  92.             if(child+1<end){
  93.                 if(array[child]<array[child+1]){
  94.                     child++;
  95.                 }
  96.             }
  97.             if(array[parent]<array[child]){
  98.                 //子女节点中最大值大于双亲则进行交换调整
  99.                 int temp=array[parent];
  100.                 array[parent]=array[child];
  101.                 array[child]=temp;
  102.                 //向下迭代
  103.                 parent=child;
  104.                 child=2*parent+1;
  105.             }else{
  106.                 //子女节点中最大值小于双亲说明该树已经为大根堆，无需向下调整，直接中断即可
  107.                 break;
  108.             }
  109.         }
  110.     }
  111.  
  112.     //利用创建的大根堆实现堆排序
  113.     public static void heapSort(int[]array){
  114.         createMaxHeap(array);
  115.         int end= array.length-1;
  116.         while(end>0){
  117.             //将堆顶元素和堆尾元素交换
  118.             int temp=array[end];
  119.             array[end]=array[0];
  120.             array[0]=temp;
  121.             //利用大根堆向下调整的方法
  122.             maxSiftDown(array,0,end);
  123.             end--;
  124.         }
  125.     }
  126. }

（2）Test类：

  1. import java.util.Arrays;
  2. import java.util.Random;
  3.  
  4. public class Test {
  5.     //生成一个顺序数组的方法
  6.     public static void order(int[] array){
  7.         for(int i=0;i< array.length;i++){
  8.             array[i]=i;
  9.         }
  10.     }
  11.  
  12.     //生成一个逆序数组的方法
  13.     public static void reverseOrder(int[] array){
  14.         for(int i=0;i<array.length;i++){
  15.             array[i]= array.length-i;
  16.         }
  17.     }
  18.  
  19.     //生成一个随机数数组的方法
  20.     public static void randomOrder(int[] array){
  21.         Random random=new Random();
  22.         for(int i=0;i<array.length;i++){
  23.             array[i]= random.nextInt(10_0000);
  24.         }
  25.     }
  26.  
  27.     //测试直接插入排序时间的方法
  28.     public static void testInsertSort(int[]array){
  29.         //拷贝一个新的数组
  30.         array= Arrays.copyOf(array,array.length);
  31.         //获取起始时间戳
  32.         long starttime=System.currentTimeMillis();
  33.         Sort.insertSort(array);
  34.         //获取终止时间戳
  35.         long endtime=System.currentTimeMillis();
  36.         //输出耗时
  37.         System.out.println("直接插入排序耗时:"+(endtime-starttime));
  38.     }
  39.  
  40.     //测试希尔排序时间的方法
  41.     public static void testShellSort(int[]array){
  42.         //拷贝一个新的数组
  43.         array= Arrays.copyOf(array,array.length);
  44.         //获取起始时间戳
  45.         long starttime=System.currentTimeMillis();
  46.         Sort.shellSort(array);
  47.         //获取终止时间戳
  48.         long endtime=System.currentTimeMillis();
  49.         //输出耗时
  50.         System.out.println("希尔排序耗时:"+(endtime-starttime));
  51.     }
  52.  
  53.     //测试直接选择排序时间的方法
  54.     public static void testSelectSort(int[]array){
  55.         //拷贝一个新的数组
  56.         array= Arrays.copyOf(array,array.length);
  57.         //获取起始时间戳
  58.         long starttime=System.currentTimeMillis();
  59.         Sort.selectSort(array);
  60.         //获取终止时间戳
  61.         long endtime=System.currentTimeMillis();
  62.         //输出耗时
  63.         System.out.println("直接选择排序耗时:"+(endtime-starttime));
  64.     }
  65.  
  66.     //测试直接选择排序时间的方法
  67.     public static void testHeapSort(int[]array){
  68.         //拷贝一个新的数组
  69.         array= Arrays.copyOf(array,array.length);
  70.         //获取起始时间戳
  71.         long starttime=System.currentTimeMillis();
  72.         Sort.heapSort(array);
  73.         //获取终止时间戳
  74.         long endtime=System.currentTimeMillis();
  75.         //输出耗时
  76.         System.out.println("堆排序耗时:"+(endtime-starttime));
  77.     }
  78.  
  79.     public static void main(String[] args) {
  80.         int[]array=new int[10_0000];
  81.         //测试顺序数组情况
  82.         System.out.println("***********************");
  83.         System.out.println("顺序数组情况：");
  84.         order(array);
  85.         testInsertSort(array);
  86.         testShellSort(array);
  87.         testSelectSort(array);
  88.         testHeapSort(array);
  89.         System.out.println("***********************");
  90.  
  91.         //测试逆序数组情况
  92.         System.out.println("逆序数组情况：");
  93.         reverseOrder(array);
  94.         testInsertSort(array);
  95.         testShellSort(array);
  96.         testSelectSort(array);
  97.         testHeapSort(array);
  98.         System.out.println("***********************");
  99.  
  100.         //测试随机数组情况
  101.         System.out.println("随机数组情况：");
  102.         randomOrder(array);
  103.         testInsertSort(array);
  104.         testShellSort(array);
  105.         testSelectSort(array);
  106.         testHeapSort(array);
  107.         System.out.println("***********************");
  108.  
  109.     }
  110. }

3.测试结果

 

上图可以直观感受各算法在不同情况下的表现。

以上便是通过Java实现插入排序（直接插入，希尔）与选择排序（直接选择，堆排）的全部内容，如有不当，敬请斧正！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/正经夜光杯/article/detail/922100
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号