排序算法详解-优快云博客

直接插入排序
1.定义
    直接插入排序（ straight insertion sort ）是一种最简单的排序方法。它的基本操作是将一个记录插入到一个长度为 m （假设）的有序表中，使之仍保持有序，从而得到一个新的长度为 m ＋ 1 的有序表。
2.算法思路
　　设有一组关键字｛ K 1 ， K 2 ，…， K n ｝；排序开始就认为 K 1 是一个有序序列；让 K 2 插入上述表长为 1 的有序序列，使之成为一个表长为 2 的有序序列；然后让 K 3 插入上述表长为 2 的有序序列，使之成为一个表长为 3 的有序序列；依次类推，最后让 K n 插入上述表长为 n-1 的有序序列，得一个表长为 n 的有序序列。
【例】设有一组关键字序列｛ 55 ， 22 ， 44 ， 11 ， 33 ｝，这里 n=5 ，即有 5 个记录。请将其按由小到大的顺序排序。排序过程如图9.1所示。

具体算法演示请点击查看【算法演示】
3.具体算法
template<class T>
void stinsort (T r[],int n)
  { int i,j;
    for (i=2;i<=n;i++)          //工进行n-1趟插入
      { r[0]=r[i];              //r[0]为监视哨，也可作下边循环结束标志
        j=i-1;
        while (r[j].key>r[0].key) { r[j+1]=r[j]; j--;}
        r[j+1]=r[0];        //将r[0]即原r[i]记录内容，插到r[j]后一位置
      }
  }    //sinsort
4.算法时间复杂度
　　此算法外循环 n-1 次，在一般情况下内循环平均比较次数的数量级为Ｏ(n) ，所以算法总时间复杂度为Ｏ(n²) 。
5.直接插入排序的稳定性
　　直接插入排序是稳定的排序方法
。

折半插入排序
1.定义
    当直接插入排序进行到某一趟时，对于 r[i].key 来讲，前边 i-1 个记录已经按关键字有序。此时不用直接插入排序的方法，而改为折半查找，找出 r[i].key 应插的位置，然后插入。这种方法就是折半插入排序（ Binary insertion sort ）。
2.具体算法
template<class T>
void binasort(T r[],int n)
  { int i,j,l,h,mid;
    for (i=2;i<=n;i++)
      { r[0]=r[i];
        l=1;h=i-1;           //认为在r[1]和r[i-1]之间已经有序
        while(l<=h)          //对有序表进行折半查找
       { mid=(l+h)/2;
        if(a[0].key<a[mid].key)h=mid-1;
        else l=mid+1;
       }        //结果在1位置
     for(j=i-1;j>=1;j--)a[j+1]=a[j];
        a[1]=a[0];
        }
  }  //binasort
3.折半插入排序的时间复杂度
　　折半插入排序，关键字的比较次数由于采用了折半查找而减少，数量级为Ｏ (nlog 2 n) ，但是元素移动次数仍为Ｏ (n 2 ) 。故折半插入排序时间复杂度仍为Ｏ (n 2 ) 。折半插入排序方法是稳定的。

希尔排序
1.定义
希尔排序（ shell sort ）是 D ．Ｌ．希尔（ D.L.Shell ）提出的“缩小增量”的排序方法。它的作法不是每次一个元素挨一个元素的比较。而是初期选用大跨步（增量较大）间隔比较，使记录跳跃式接近它的排序位置；然后增量缩小；最后增量为 1 ，这样记录移动次数大大减少，提高了排序效率。希尔排序对增量序列的选择没有严格规定。
2.算法思路
　　①先取一个正整数 d ₁ (d 1 <;n) ，把全部记录分成 d ₁ 个组，所有距离为 d ₁ 的倍数的记录看成一组，然后在各组内进行插入排序；
　　②然后取 d ₂ ( d ₂ < d ₁ ) 。
　　③重复上述分组和排序操作；直到取 d _i =1(i>=1) ，即所有记录成为一个组为止。一般选 d ₁ 约为 n/2 ， d ₂ 为 d 1 /2 ， d ₃ 为 d 2 /2 ，…， d i =1 。

　　【例】有一组关键字｛ 76 ， 81 ， 60 ， 22 ， 98 ， 33 ， 12 ， 79 ｝，将其按由小到大的顺序排序。这里 n=8 ，取 d 1 =4 ， d 2 =2 ， d 3 =1 。排序过程如图9.2所示。

　　具体算法演示请点击查看【算法演示】
3.具体算法
template<class T>
void shell(T r[],int n)         //希尔排序
  { int i,j,k;
    k=n/2;//k值代表前文中的增量d值
    while(k>=1)           //当增量k值变化到0，结束循环……
       { for(i=k+1;i<=n;i++)
           { r[0].key=r[i].key;j=i-k;
             while((r[j].key>r[0].key)&&(j>=0))
                 { r[j+k].key=r[j].key;j=j-k;}
                   r[j+k]=r[0];
            }
             k=k/2;
       }
  }
4.算法分析
　　当K=1时，此算法就等同于直接插入排序方法。由于前边大增量的处理，使关键字大体有序，因此最后一趟排序移动的记录少，处理速度快。
　　有人在大量实验基础上推出，它的时间复杂长为 O(n 1.3 ) 。如果对关键字序列 {6,7,5 1 ,2,5 2 ,8} 进行希尔排序，可以看出希尔排序是不稳定的。