各种排序算法分析

相关概念

1、稳定排序（stable sort）和非稳定排序

稳定排序是指所有相等的数经过某种排序算法操作后仍然能保持它们在排序之前的相对次序。反之就是非稳定排序。

2、内排序（internal sorting）和外排序（external sorting）

在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。

 

排序算法

 

【冒泡排序】（Bubble Sort）

冒泡排序方法是最简单的排序方法。这种方法的基本思想是，将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮。在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即“轻”的元素在下面，就交换它们的位置。显然，处理一遍之后，“最轻”的元素就浮到了最高位置；处理二遍之后，“次轻”的元素就浮到了次高位置。在作第二遍处理时，由于最高位置上的元素已是“最轻”元素，所以不必检查。一般地，第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排好序。 

冒泡排序是稳定的。算法时间复杂度是O(n2)。 例子如下：

main()
{
int i,j,temp;
int a[10];
for(i=0;i<10;i++)
scanf ("%d,",&a[i]);
for(j=0;j<=9;j++)
{ 

for (i=0;i<10-j;i++)
if (a[i]>a[i+1])
{ 

temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;}
}
for(i=1;i<11;i++)
printf("%d,",a[i] );
}

 

【选择排序】（Selection Sort）

选择排序的基本思想是对待排序的记录序列进行n-1遍的处理，第 i 遍处理是将[i..n]中最小者与位置 i 交换位置。这样，经过 i 遍处理之后，前 i 个记录的位置已经是正确的了。 

选择排序是不稳定的。算法复杂度是O(n2 )。 例子如下：

 main()
{
  int i,j,k,a[10];
  for (i=0;i<10;i++)
    scanf("%d",&a[i]);
  for (i=0;i<9;i++)
   {
     k=i;
    for (j=i+1;j<10;++j)
     if (a[k]>a[j]) k=j;
    if (k!=i)
    {
     j=a[i];
     a[i]=a[k];
     a[k]=j;
    }
  }
  for (i=0;i<10;++i) printf("%d ",a[i]);
}

 

【插入排序】（Insertion Sort）

插入排序的基本思想是，经过i-1遍处理后,L[1..i-1]己排好序。第i遍处理仅将L插入L[1..i-1]的适当位置，使得L[1..i]又是排好序的序列。要达到这个目的，我们可以用顺序比较的方法。首先比较L和L[i-1]，如果L[i-1]≤ L，则L[1..i]已排好序，第i遍处理就结束了；否则交换L与L[i-1]的位置，继续比较L[i-1]和L[i-2]，直到找到某一个位置j(1≤j≤i-1)，使得L[j] ≤L[j+1]时为止。

直接插入排序是稳定的。算法时间复杂度是O(n2) 

int insert_order(int a[],int num)
{
 int i,j,k;
 int tmp;
 for(i=0;i<num;i++)
 {
  tmp = a[i];
  for(j=0;j<i;j++)
  {
   if(tmp<a[j])
   {
    for(k=i;k>j;k--)
    {
     a[k]=a[k-1];
    }
    a[j]=tmp;
    break;
   }
  }

 

【堆排序】（Heap Sort）

 

堆排序是一种树形选择排序，在排序过程中，将A[n]看成是完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系来选择最小的元素。 

堆排序是不稳定的。算法时间复杂度O(nlog2n)。 

 void    HeapSort(RecType R[]，int n)
{ //对记录序列R[1..n]进行堆排序。
  for(i=n/2;i>0;i--)       //把R[1..n]建成大顶堆
      Sift(R,i,n);
  for(i=n;i>1;i--)
{ //将堆顶记录和当前未经排序子序列R[1..i]中最后一个记录相互交换
R[1]←→R[i];
Sift(R,1,i-1);    //将R[1..i-1]重新调整为大顶堆
}//for
}//HeapSort

 

【归并排序】（Merge Sort）

 

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

归并排序是稳定的。其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlog2n)。 

void MSort(ElemType *p，ElemType *p1，int s，int t)

 { /*将p[s…t]归并排序为p1[s…t]*/

 if(s==t) p1[s]=p[s]

 else

 { m=(s+t)/2； /*平分*p 表*/

MSort(p，p2，s，m)； /*递归地将p[s…m]归并为有序的p2[s…m]*/

 MSort(p，p2，m+1，t)； /*递归地将p[m+1…t]归并为有序的p2[m+1…t]*/

 Merge(p2，p1，s，m+1，t)； /*将p2[s…m]和p2[m+1…t]归并到p1[s…t]*/

 }

 }

 void MergeSort(S_TBL *p)

 { /*对顺序表*p 作归并排序*/

MSort(p->elem，p->elem，1，p->length)；

}

 

【快速排序】（Quick Sort）

 

快速排序是对冒泡排序的一种本质改进。它的基本思想是通过一趟扫描后，使得排序序列的长度能大幅度地减少。在冒泡排序中，一次扫描只能确保最大数值的数移到正确位置，而待排序序列的长度可能只减少1。快速排序通过一趟扫描，就能确保某个数（以它为基准点吧）的左边各数都比它小，右边各数都比它大。然后又用同样的方法处理它左右两边的数，直到基准点的左右只有一个元素为止。 

快速排序是不稳定的。最理想情况算法时间复杂度O(nlog2n)，最坏O(n ^2)。

void qsort(int s[], int l, int r)

{

    int i, j, x;

    if (l < r)

    {

        i = l;

        j = r;

        x = s[i];

        while (i < j)

        {

            while(i < j && s[j] > x) j--; /* 从右向左找第一个小于x的数 */

            if(i < j) s[i++] = s[j];

            while(i < j && s[i] < x) i++; /* 从左向右找第一个大于x的数 */

            if(i < j) s[j--] = s[i];

        }

        s[i] = x;

        qsort(s, l, i-1); /* 递归调用 */

        qsort(s, i+1, r);

    }

}

各排序方法对比

冒泡排序算法时间复杂度是O(n^2)

选择排序算法时间复杂度是O(n^2)

插入排序算法时间复杂度是O(n^2)

快速排序是不稳定的。最理想情况算法时间复杂度O(nlog2n)，最坏O(n^2)。

堆排序算法时间复杂度是O(nlogn)

归并排序算法时间复杂度是O(nlogn)