排序算法

参考MOOC浙大算法与数据结构课程

 

排序方法	平均时间复杂度	最坏情况下时间复杂度	额外空间复杂度	稳定性
简单选择排序				不稳定
冒泡排序				稳定
直接插入排序				稳定
希尔排序				不稳定
堆排序				不稳定
快速排序				不稳定
归并排序				稳定
基数排序				稳定

/*冒泡排序*/

void Bubble_Sort( ElementType A[], int N )

{

    for(int P=N-1; P>=0; P--)

    {

        int flag=0;

        for(int i=0; i<P ;i++)

        {

            if(A[i]>A[i+1])

            {

                swap(A[i],A[i+1]);

                flag=1;

            }

        }

        if(flag==0) break;//一趟冒泡无交换，表示已有序

    }

}

 /* 插入排序 */

void Insertion_Sort( ElementType A[], int N )

{

    int P,i;

    ElementType Tmp;

    for (P=1; P<N; P++ )//调试数字从左到右

    {

        Tmp = A[P]; //当前要插入的数

        for (i=P; i>0 && A[i-1]>Tmp; i-- )//从该数开始，与前面的数比较

            A[i] = A[i-1]; //把比tmp大的数 右移

        A[i] = Tmp; // i即为最后要放的位置

    }

}

****概念：时间复杂度下界

****概念：逆序对，对下标i<j,如果 a[i]>a[j],称（i,j）是一对逆序对inversion

//34, 8, 64, 51, 32, 21 的逆序对个数为9

//而以上的交换，每交换2个相邻元素正好消去一个逆序对

****定理：任意N个不同元素组成的序列 平均具有N(N-1)/4个逆序对

****定理：任何仅以交换相邻两元素来排序的算法，其平均时间复杂度为 (N*N) 【时间复杂度下界】

这意味这：要提高效率，我们要跳着交换

/*桶排序 */...

/* 希尔排序 - 用Sedgewick增量序列 */

 

举例：对数列，先进行5-间隔排序，再进行3-间隔排序，最后进行1-间隔排序

就是：定义了一个增量序列Dm>Dm-1>...>D1=1 ，

     对每个Dk进行，“Dk-间隔”排序

 

（1）希尔增量序列

··原始希尔排序： Dm=N/2, Dk=Dk+1/2

··最坏的情况：O(N*N)

··举例：1 9 2 10 3 11 4 12 5 13 6 14 7 15 8 16  //8-4-2-间隔排序无效

 

##增量序列，相邻元素不互质

改进一下：Hibbard增量序列：Dk=2^k-1使得相邻元素互质

··最坏情况：O(N^3/2) 猜想，平均O(N^5/4)

其他改进，Sedgewick增量序列：9×4^i-9×2^i+1 或者 4^i-3×2^i+1

··最坏情况：O(N^4/3) 猜想，平均O(N^7/6)

void ShellSort( ElementType A[], int N )

{

    int Si, D, P, i;

    ElementType Tmp;

    

    int Sedgewick[] = {929, 505, 209, 109, 41, 19, 5, 1, 0};//这里只列出一小部分增量      

    for ( Si=0; Sedgewick[Si]>=N; Si++ ); //初始的增量Sedgewick[Si]不能超过待排序列长度

    for ( D=Sedgewick[Si]; D>0; D=Sedgewick[++Si] )

    for ( P=D; P<N; P++ ) //插入排序

    {

        Tmp = A[P];

        for ( i=P; i>=D && A[i-D]>Tmp; i-=D )//每隔D个进行比较

            A[i] = A[i-D];

        A[i] = Tmp;

    }

}

/*堆排序*/

对选择排序的一种改良，如何快速找到最小元？？

建堆，更新最大堆，把堆顶元素与最后一个元素交换，对剩下的前（n--）个数继续更新（数组下标从0开始）

Ps：·

·定理：堆排序处理N个不同元素的随机排列的平均比较次数是

2NlogN - O(Nlog log N)

··虽然堆排序给出最佳时间复杂度，但实际效果不如用Sedgewick增量序列的希尔排序。

void Swap( ElementType *a, ElementType *b )

{

    ElementType t = *a; *a = *b; *b = t;

}

void PercDown( ElementType A[], int p, int N )

{ ///将N个元素的数组中以A[p]为根的子堆调整为最大堆

    int Parent, Child;

    ElementType X;

 

    X = A[p]; /// 取出根结点存放的值

    for( Parent=p; (Parent*2+1)<N; Parent=Child )

    {

        Child = Parent * 2 + 1;

        if( (Child!=N-1) && (A[Child]<A[Child+1]) ) Child++;///取孩子的较大者

        if( X >= A[Child] ) break; /// 找到了合适位置

        else  A[Parent] = A[Child];///下滤X

    }

    A[Parent] = X;

}

void Heap_Sort( ElementType A[], int N )

{

    int i;

    for (i=N/2-1;i>=0;i--) PercDown( A, i, N );/// 建立最大堆

    for (i=N-1;i>0;i--)  /// 删除最大堆顶

    {

        Swap( &A[0], &A[i] );

        PercDown( A, 0, i );

    }

}

//归并排序概述

核心：有序子列的归并

//两个子列，一个最终序列，需要三个指针

1 13 24 26

2 15 27 38

每次都把子列当前位置 最小的元素放到第三个（有序）数组中。

容易知道，两个子列一共N个元素，则归并的时间复杂度为 O(N)

/* 归并排序 - 递归实现 */

/* L = 左边起始位置, R = 右边起始位置, RightEnd = 右边终点位置*/

void Merge( ElementType A[], ElementType TmpA[], int L, int R, int RightEnd )

{ /* 将有序的A[L]~A[R-1]和A[R]~A[RightEnd]归并成一个有序序列 */

     int LeftEnd, NumElements, Tmp;

     int i;

      

     LeftEnd = R - 1; /* 左边终点位置 */

     Tmp = L;         /* 有序序列的起始位置 */

     NumElements = RightEnd - L + 1;

      

     while( L <= LeftEnd && R <= RightEnd ) {

         if ( A[L] <= A[R] )

             TmpA[Tmp++] = A[L++]; /* 将左边元素复制到TmpA */

         else

             TmpA[Tmp++] = A[R++]; /* 将右边元素复制到TmpA */

     }

 

     while( L <= LeftEnd )

         TmpA[Tmp++] = A[L++]; /* 直接复制左边剩下的 */

     while( R <= RightEnd )

         TmpA[Tmp++] = A[R++]; /* 直接复制右边剩下的 */

          

     for( i = 0; i < NumElements; i++, RightEnd -- )

         A[RightEnd] = TmpA[RightEnd]; /* 将有序的TmpA[]复制回A[] */

}

 

void Msort( ElementType A[], ElementType TmpA[], int L, int RightEnd )

{ /* 核心递归排序函数 */

     int Center;

      

     if ( L < RightEnd ) {

          Center = (L+RightEnd) / 2;

          Msort( A, TmpA, L, Center );              /* 递归解决左边 */

          Msort( A, TmpA, Center+1, RightEnd );     /* 递归解决右边 */  

          Merge( A, TmpA, L, Center+1, RightEnd );  /* 合并两段有序序列 */

     }

}

 

void Merge_Sort( ElementType A[], int N )

{ /* 归并排序 */

     ElementType *TmpA;

     TmpA = (ElementType *)malloc(N*sizeof(ElementType));

      

     if ( TmpA != NULL ) {

          Msort( A, TmpA, 0, N-1 );

          free( TmpA );

     }

     else printf( "空间不足" );

}

/* 归并排序 - 循环实现 */

额外的空间复杂度为 O(n)

///L = 左边起始位置, R = 右边起始位置, RightEnd = 右边终点位置

void Merge( ElementType A[], ElementType TmpA[], int L, int R, int RightEnd )

{ ///将有序的A[L]~A[R-1]和A[R]~A[RightEnd]归并成一个有序序列

    int LeftEnd= R-1,Tmp=L;///左边终点位置,有序序列的起始位置

    while( L <= LeftEnd && R <= RightEnd ) ///复制小的那个数到TmpA

    {

        if ( A[L] <= A[R] ) TmpA[Tmp++] = A[L++];

        else TmpA[Tmp++] = A[R++];

    }

    ///左边/右边 有剩下，直接复制在TmpA后面

    while( L <= LeftEnd ) TmpA[Tmp++] = A[L++];

    while( R <= RightEnd ) TmpA[Tmp++] = A[R++];

}

    /// length = 当前有序子列的长度

void Merge_pass( ElementType A[], ElementType TmpA[], int N, int length )

{ /// 两两归并相邻有序子列

    int i, j;

    for ( i=0; i <= N-2*length; i += 2*length )

        Merge( A, TmpA, i, i+length, i+2*length-1 );

    if ( i+length < N ) Merge( A, TmpA, i, i+length, N-1);/// 归并最后2个子列

    else /// 最后只剩1个子列

    {

        for ( j = i; j < N; j++ )

            TmpA[j] = A[j];

    }

}

void Merge_Sort( ElementType A[], int N )

{

    int length;

    ElementType *TmpA;

 

    length = 1; /// 初始化子序列长度

    TmpA =(ElementType *)malloc(N*sizeof(ElementType)) ;

    if ( TmpA != NULL )

    {

        while( length < N )

        {

            Merge_pass( A, TmpA, N, length );

            length *= 2;

            Merge_pass( TmpA, A, N, length );

            length *= 2;

        }

        free( TmpA );

    }

    else printf( "空间不足" );

}

/* 快速排序 - 直接调用库函数 */...

/* 快速排序 */

··算法概述：用分而治之的策略

··从数字中，找到一个pivot（主元，中枢，枢纽）；后来把原数组分成两部分；两部分 分别排序（递归上面的步骤），后来合并

··最好情况：每次主元正好中分，复杂度（NlogN）

``关于选主元：

   （1）令pirvot = A[0] 如果原来就是有序的话，复杂度会高达O(N*N)

    (2) 随机取pivot？ 但是rand()函数不便宜啊！

(3) 取头、中、尾的中位数

``子集划分，按照pivot划分为左右两块，i++,j--,不对的时候就交换；最后得到的i的位置就是pivot的位置，再交换一下就行。 一次子集划分定下来的 pivot，它的位置，就是最后在结果数组里面的正确位置了。不会再移动了。

``如果有元素正好等于pivot怎么办？？

    （1）停下来交换？？

做了很多无谓的交换，但是最后i，j会停在比较中间的位置，复杂度NlogN

    （2）不理他，继续移动指针？？

那么就回到之前最窘的状态，指针停滞在一边了，复杂度退化到N*N

``小规模数据的处理

  （1）快速排序的问题

用了递归

对小规模的数据（例如N不到100）可能还不如插入排序快

  （2）解决方案

当递归的数据规模充分小，则停止递归，直接调用简单排序（如插入排序）

可以在程序中定义一个Cutoff的阈值

 

void Swap( ElementType *a, ElementType *b )

{

    ElementType t = *a; *a = *b; *b = t;

}

void Insertion_Sort( ElementType A[], int N )

{

    int P,i;

    ElementType Tmp;

    for (P=1; P<N; P++ )//调试数字从左到右

    {

        Tmp = A[P]; //当前要插入的数

        for (i=P; i>0 && A[i-1]>Tmp; i-- )//从该数开始，与前面的数比较

            A[i] = A[i-1]; //把比tmp大的数 右移

        A[i] = Tmp; // i即为最后要放的位置

    }

}

ElementType Median3( ElementType A[], int Left, int Right )

{

    int Center = (Left+Right) / 2;

    if ( A[Left] > A[Center] )

        Swap( &A[Left], &A[Center] );

    if ( A[Left] > A[Right] )

        Swap( &A[Left], &A[Right] );

    if ( A[Center] > A[Right] )

        Swap( &A[Center], &A[Right] );

    /* 此时A[Left] <= A[Center] <= A[Right] */

    Swap( &A[Center], &A[Right-1] ); /* 将基准Pivot藏到右边*/

    /* 只需要考虑A[Left+1] … A[Right-2] */

    return  A[Right-1];  /* 返回基准Pivot */

}

 

void Qsort( ElementType A[], int Left, int Right )

{ /* 核心递归函数 */

     int Pivot, Cutoff, Low, High;

     Cutoff=5000;

     if ( Cutoff <= Right-Left ) { /* 如果序列元素充分多，进入快排 */

          Pivot = Median3( A, Left, Right ); /* 选基准 */

          Low = Left; High = Right-1;

          while (1) { /*将序列中比基准小的移到基准左边，大的移到右边*/

               while ( A[++Low] < Pivot ) ;

               while ( A[--High] > Pivot ) ;

               if ( Low < High ) Swap( &A[Low], &A[High] );

               else break;

          }

          Swap( &A[Low], &A[Right-1] );   /* 将基准换到正确的位置 */

          Qsort( A, Left, Low-1 );    /* 递归解决左边 */

          Qsort( A, Low+1, Right );   /* 递归解决右边 */

     }

     else Insertion_Sort( A+Left, Right-Left+1 ); /* 元素太少，用简单排序 */

}

void Quick_Sort( ElementType A[], int N )

{ /* 统一接口 */

     Qsort( A, 0, N-1 );

}

/*基数排序*/

#include <bits/stdc++.h>

using namespace std;

 

const int maxn=1e5+5;

int n,xx;

int sum[10],id[maxn],rk[maxn];//id[i]表示第k+1到n号关键字排好后第i个数据的原本编号，rk[i]表示原本编号为i的数据在进行完k号关键字的计数排序后的排名

int *x=id,*y=rk;//因为到时候要交换数组，用指针就是O(1)的了。

 

 

struct num {

    int val[11];

 

    void print()

    {

        int pos=1;

        while(pos<=10&&!val[pos])pos++;//忽略前导零

        for(int i=pos;i<=10;i++)

            printf("%d",val[i]);

        printf(" ");

    }

}a[maxn];

void Base_Sort()

{

    for(int key=10;key;key--) {//倒着做基数排序

        memset(sum,0,sizeof(sum));

        for(int i=1;i<=n;i++)sum[a[i].val[key]]++;

        for(int i=1;i<=9;i++)sum[i]+=sum[i-1];

        for(int i=n;i;i--)y[sum[a[x[i]].val[key]]--]=x[i];//y[i]记录排名第i的数据，记住不要把a[x[i]]写成a[i]了，x是之前全部排好后的顺序

        for(int i=1;i<=n;i++)x[y[i]]=i;//x[i]记录第i个数据的排名

        swap(x,y);//交换，不然做下一次id和rk的意思就反了

    }

}

 

int main()

{

    cin>>n;

    for(int i=1;i<=n;i++)

    {

        cin>>xx;

        for(int j=10;j;j--)

        {

            a[i].val[j]=xx%10;

            xx/=10;

        }

        id[i]=i;//把整数拆成10个关键字排序，每个关键字的值域都是[0,9]

    }

    Base_Sort();

    for(int i=1;i<=n;i++)

        a[x[i]].print();//输出

    return 0;

}