插入排序及改进

插入排序

基本思想

在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数找到相应位置并插入，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。

java实现

[java] view plain copy print?

  1. //插入排序
  2. public void insertionSort(){
  3. int len = array.length;
  4. int counter = 1;
  5. for(int i=1;i<len;i++){
  6. int temp = array[i];  //存储待排序的元素值
  7. int insertPoint = i-1;  //与待排序元素值作比较的元素的下标
  8. while(insertPoint>=0 && array[insertPoint]>temp){ //当前元素比待排序元素大
  9. array[insertPoint+1]= array[insertPoint];  //当前元素后移一位
  10. insertPoint--;
  11. }
  12. array[insertPoint+1]= temp;  //找到了插入位置，插入待排序元素
  13. System.out.print("第"+counter+"轮排序结果：");
  14. display();
  15. counter++;
  16. }
  17. }

//插入排序
public void insertionSort(){

       int len = array.length;
       int counter = 1;

       for(int i=1;i<len;i++){

          int temp = array[i];  //存储待排序的元素值
          int insertPoint = i-1;  //与待排序元素值作比较的元素的下标

          while(insertPoint>=0 && array[insertPoint]>temp){ //当前元素比待排序元素大
              array[insertPoint+1]= array[insertPoint];  //当前元素后移一位
              insertPoint--;
          }
          array[insertPoint+1]= temp;  //找到了插入位置，插入待排序元素

          System.out.print("第"+counter+"轮排序结果：");
          display();
          counter++;
       }
   }

算法分析

在第一趟排序中，插入排序最多比较一次，第二趟最多比较两次，依次类推，最后一趟最多比较N-1次。因此有：

1+2+3+...+N-1 =N*N(N-1)/2

因为在每趟排序发现插入点之前，平均来说，只有全体数据项的一半进行比较，我们除以2得到：

N*N(N-1)/4

复制的次数大致等于比较的次数，然而，一次复制与一次比较的时间消耗不同，所以相对于随机数据，这个算法比冒泡排序快一倍，比选择排序略快。

与冒泡排序、选择排序一样，插入排序的时间复杂度仍然为O(N2)，这三者被称为简单排序或者基本排序，三者都是稳定的排序算法。

如果待排序数组基本有序时，插入排序的效率会更高。

插入排序的改进

在插入某个元素之前需要先确定该元素在有序数组中的位置，上例的做法是对有序数组中的元素逐个扫描，当数据量比较大的时候，这是一个很耗时间的过程，可以采用二分查找法改进，这种排序也被称为二分插入排序。

改进后的代码如下：

[java] view plain copy print?

  1. //二分插入排序
  2. public void BinaryInsertionSort(){
  3. int len = array.length;
  4. int counter = 1;
  5. for(int i=1;i<len;i++){
  6. int temp = array[i];  //存储待排序的元素值
  7. if(array[i-1]>temp){  //比有序数组的最后一个元素要小
  8. intinsertIndex = binarySearch(0, i-1, temp); //获取应插入位置的下标
  9. for(int j=i;j>insertIndex;j--){  //将有序数组中，插入点之后的元素后移一位
  10. array[j]= array[j-1];
  11. }
  12. array[insertIndex]= temp;  //插入待排序元素到正确的位置
  13. }
  14. System.out.print("第"+counter+"轮排序结果：");
  15. display();
  16. counter++;
  17. }
  18. }
  19. /**
  20. * 二分查找法
  21. * @param lowerBound 查找段的最小下标
  22. * @param upperBound 查找段的最大下标
  23. * @param target 目标元素
  24. * @return 目标元素应该插入位置的下标
  25. */
  26. public int binarySearch(int lowerBound,int upperBound,int target){
  27. int curIndex;
  28. while(lowerBound<upperBound){
  29. curIndex= (lowerBound+upperBound)/2;
  30. if(array[curIndex]>target){
  31. upperBound= curIndex - 1;
  32. }else{
  33. lowerBound= curIndex + 1;
  34. }
  35. }
  36. return lowerBound;
  37. }

//二分插入排序
   public void BinaryInsertionSort(){

       int len = array.length;
       int counter = 1;

       for(int i=1;i<len;i++){

          int temp = array[i];  //存储待排序的元素值

          if(array[i-1]>temp){  //比有序数组的最后一个元素要小

              intinsertIndex = binarySearch(0, i-1, temp); //获取应插入位置的下标
              for(int j=i;j>insertIndex;j--){  //将有序数组中，插入点之后的元素后移一位
                 array[j]= array[j-1];
              }

              array[insertIndex]= temp;  //插入待排序元素到正确的位置
          }

          System.out.print("第"+counter+"轮排序结果：");
          display();
          counter++;
       }
   }

   /**
    * 二分查找法
    * @param lowerBound 查找段的最小下标
    * @param upperBound 查找段的最大下标
    * @param target 目标元素
    * @return 目标元素应该插入位置的下标
    */
   public int binarySearch(int lowerBound,int upperBound,int target){
       int curIndex;
       while(lowerBound<upperBound){
          curIndex= (lowerBound+upperBound)/2;
          if(array[curIndex]>target){
              upperBound= curIndex - 1;
          }else{
              lowerBound= curIndex + 1;
          }
       }
       return lowerBound;
   }

还有一种在二分插入排序的基础上进一步改进的排序，称为2-路插入排序，其目的是减少排序过程中移动记录的次数，但为此需要n个记录的辅助空间。

算法的思想为：另设一个和原始待排序列L相同的数组D，首先将L[1]复制给D[1]，并把D[1]看成是已排好序的序列中处于中间位置的元素（枢纽元素），之后将L中的从第二个元素开始依次插入到数组D中，大于D[1]的插入到D[1]之后的序列(此处我称为右半边序列，用的是数组左半部分空间)，小于D[1]的插入到D[1]之前的序列(左半边序列，用的是数组右半部分空间)。

该算法将数组当做首尾衔接的环形结构来使用。

示意图如下：

排序完成之后，数组中的元素并不是按照下标升序排列的，而是靠first与final指针确定起始元素。

注意：当L[1]为最小值时，2-路插入排序失去它的优越性，等同于二分插入排序。

代码如下：

[java] view plain copy print?

  1. //2-路插入排序
  2. public void two_wayInsertionSort(){
  3. int len = array.length;
  4. int [] newArray = new int [len];
  5. newArray[0]= array[0];  //将原数组的第一个元素作为枢纽元素
  6. int first = 0;  //指向最小元素的指针
  7. int last = 0;   //指向最大元素的指针
  8. for(int j=0;j<newArray.length;j++){  //打印初始化数组
  9. System.out.print(newArray[j]+"\t");
  10. }
  11. System.out.println();
  12. for(int i=1;i<len;i++){
  13. if(array[i]>= newArray[last]){  //大于等于最大元素，直接插入到last后面，不用移动元素
  14. last++;
  15. newArray[last]= array[i];
  16. }else if(array[i] < newArray[first]){  //小于最小元素，直接插到first前面，不用移动元素
  17. first= (first-1+len) % len;
  18. newArray[first]= array[i];
  19. }else if(array[i] >= newArray[0]){  //在最大值与最小值之间，且大于等于枢纽元素，插入到last之前，需要移动元素
  20. int curIndex = last;
  21. last++;
  22. do{  //比array[i]大的元素后移一位
  23. newArray[curIndex+1]= newArray[curIndex];
  24. curIndex--;
  25. }while(newArray[curIndex]>array[i]);
  26. newArray[curIndex+1]= array[i];  //插入到正确的位置
  27. }else{  //在最大值与最小值之间，且小于枢纽元素，插入到first之后，需要移动元素
  28. int curIndex = first;
  29. first= (first-1+len) % len;
  30. do{  //比array[i]小的元素前移一位
  31. newArray[curIndex-1]= newArray[curIndex];
  32. curIndex= (curIndex+1+len)%len;
  33. }while(newArray[curIndex]<=array[i]);
  34. newArray[(curIndex-1+len)%len]= array[i];  //插入到正确的位置
  35. }
  36. for(int j=0;j<newArray.length;j++){  //打印新数组中的元素
  37. System.out.print(newArray[j]+"\t");
  38. }
  39. System.out.println();
  40. }
  41. }

   //2-路插入排序
   public void two_wayInsertionSort(){

       int len = array.length;
       int [] newArray = new int [len];
       newArray[0]= array[0];  //将原数组的第一个元素作为枢纽元素
       int first = 0;  //指向最小元素的指针
       int last = 0;   //指向最大元素的指针

       for(int j=0;j<newArray.length;j++){  //打印初始化数组
          System.out.print(newArray[j]+"\t");
       }
       System.out.println();

       for(int i=1;i<len;i++){

          if(array[i]>= newArray[last]){  //大于等于最大元素，直接插入到last后面，不用移动元素
              last++;
              newArray[last]= array[i];
          }else if(array[i] < newArray[first]){  //小于最小元素，直接插到first前面，不用移动元素
              first= (first-1+len) % len;
              newArray[first]= array[i];
          }else if(array[i] >= newArray[0]){  //在最大值与最小值之间，且大于等于枢纽元素，插入到last之前，需要移动元素
              int curIndex = last;
              last++;
              do{  //比array[i]大的元素后移一位
                 newArray[curIndex+1]= newArray[curIndex];
                 curIndex--;
              }while(newArray[curIndex]>array[i]);

              newArray[curIndex+1]= array[i];  //插入到正确的位置
          }else{  //在最大值与最小值之间，且小于枢纽元素，插入到first之后，需要移动元素
              int curIndex = first;
              first= (first-1+len) % len;
              do{  //比array[i]小的元素前移一位
                 newArray[curIndex-1]= newArray[curIndex];
                 curIndex= (curIndex+1+len)%len;
              }while(newArray[curIndex]<=array[i]);

              newArray[(curIndex-1+len)%len]= array[i];  //插入到正确的位置
          }

          for(int j=0;j<newArray.length;j++){  //打印新数组中的元素
              System.out.print(newArray[j]+"\t");
          }
          System.out.println();

       }
   }

如果对如下数组进行排序

8,1,11,12,4,20,7,2,6,15

打印结果如下：

此时，first指向下标为5的元素（1），last指向下标为4的元素（20）

时间： 2024-08-04 18:31:27

插入排序及改进的相关文章

排序算法（三）——插入排序及改进

插入排序 基本思想 在要排序的一组数中,假设前面(n-1)[n>=2] 个数已经是排好顺序的,现在要把第n个数找到相应位置并插入,使得这n个数也是排好顺序的.如此反复循环,直到全部排好顺序. java实现 //插入排序 public void insertionSort(){ int len = array.length; int counter = 1; for(int i=1;i<len;i++){ int temp = array[i]; //存储待排序的元素值 int insertPo

排序算法(一) 直接插入排序及改进

直接插入排序 直接插入排序就是每步将一个待排序的记录按其关键字的大小插到前面已经排序的序列中的适当位置,直到全部记录插入完毕为止.比较简单就直接上代码了. 代码 public static <T extends Comparable<? super T>> void insertionSort(T[] a) { int j; for (int i = 1; i < a.length; i++) { T tmp = a[i]; for (j = i; j > 0 &

希尔排序（插入排序的改进）C++实现

算法描述: 相对于直接插入排序,希尔排序将数组元素按下标的一定增量分组,对每组进行直接插入排序,随着增量的不断减小,每组包含的元素也就越多,当增量为1时,整个数组被分为一个组,进行直接插入排序之后结束. 下面给出随机整数数组的希尔排序C++实现: #include <iostream> #include <math.h> using namespace std; const int Num=20; void exch(int* s,int a,int b) { int mid=s[

插入排序算法之直接插入排序和希尔排序

插入排序算法 有一个已经有序的数据序列,要求在这个已经排好的数据序列中插入一个数,但要求插入后此数据序列仍然有序,这个时候就要用到一种新的排序方法--插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而得到一个新的.个数加一的有序数据. 直接插入排序 直接插入排序的排序思路是:每次将一个待排序的元素与已排序的元素进行逐一比较,直到找到合适的位置按大小插入. 例子: 有序列: 开始时,有序序列只有一个元素就是第一个元素(红色),后面的无序序列(绿色).接下来,取无序序列中

PHP 插入排序 -- 希尔排序

1.希尔排序 -- Shell Insertion Sort 时间复杂度:数学家正在勤劳的探索! 适用条件: 直接插入排序的改进,主要针对移动次数的减少,这取决于"增量队列"的取值.适用的情况凭个人感觉用吧,我也不知道,反正,我并不认为自己是一个程序员,喜欢凭感觉行事. 1 <?php 2 $arr = [3,4,5,1,11,9,27,27,18,20]; 3 4 5 function shellSort(array &$arr,$dt) 6 { 7 // 跟增量相关,

插入排序------直接插入排序

最优复杂度:当输入数组就是排好序的时候,复杂度为O(n),而快速排序在这种情况下会产生O(n^2)的复杂度. 最差复杂度:当输入数组为倒序时,复杂度为O(n^2)           其实插入排序的复杂度和逆序对的个数一样,当数组倒序时,逆序对的个数为n(n-1)/2,因此插入排序复杂度为O(n^2). 插入排序比较适合用于"少量元素的数组". 如果碰见一个和插入元素相等的,那么插入元素把想插入的元素放在相等元素的后面.所以,相等元素的前后顺序没有改变,从原无序序列出去的顺序就是排好序

排序算法总结之折半插入排序

基本思想 折半插入排序是对直接插入排序的简单改进,对于直接插入排序而言,当第i-1趟需要将第i个元素插入前面的0~i-1个元素序列中时,总是需要从i-1个元素开始,逐个比较每个元素,直到找到它的位置.这显然没有利用前面0~i-1个元素已经有序这个特点,而折半插入排序则改进了这一点. 对于折半插入排序而言,当需要插入第i个元素时,它不会逐个进行比较每个元素,而是: (1)计算0~i-1索引的中间点,也就是用i索引处的元素和(0+i-1)/2索引处的元素进行比较,如果i索引处的元素值大,就直接在(0

快速排序 &amp;&amp; 希尔排序 &amp;&amp; 插入排序

1. 快速排序 不稳定的排序. 平均(与最好情况)时间复杂度:O(nlgn)   |  最坏情况时间复杂度(元素有序,递归栈为 O(n)):O(n2) 适合的数据结构:数组,双向链表. #include <stdio.h> #include <stdlib.h> int partition(int data[], int low, int high) { int value = data[low]; // can be done randomly while(low < hi

[转] 插入排序

一.直接插入排序算法: void insertSort(int* data, int len){ int sentry;//哨兵 int i,j; for(i = 1; i < len; i ++){//从第二个元素开始排序,前面的一个元素默认有序了 if (data[i] < data[i-1]){ sentry = data[i];//复制为哨兵 for(j = i-1; sentry < data[j]; j --){ data[j+1] = data[j];//记录后移 } da