排序大法

测评要求

给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。
本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下：
数据1：只有1个元素；
数据2：11个不相同的整数，测试基本正确性；
数据3：103个随机整数；
数据4：104个随机整数；
数据5：105个随机整数；
数据6：105个顺序整数；
数据7：105个逆序整数；
数据8：105个基本有序的整数；
数据9：105个随机正整数，每个数字不超过1000。

Part 1：冒泡法

时间复杂度（最坏）——T(N)=O(N^2)
优点——稳定、可用于链表排序
代码如下：

void Bubble_Sort(int 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]){
              int tmp=A[i];A[i]=A[i+1];A[i+1]=tmp;
              flag=1；} 
       if(flag==0) break; }
}

运行结果：

Part 2：插入排序

时间复杂度T(N)=O(N^2)
代码如下：

void InsertionSort( 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]; /*依次与已排序序列中元素比较并右移*/         
          A[i] = Tmp; /* 放进合适的位置 */     }
}

Part 3：希尔排序

T=θ（N^2)
代码如下：

void ShellSort( ElementType A[], int N )
{ /* 希尔排序 - 用Sedgewick增量序列 */     
    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 )                
            A[i] = A[i-D];            
            A[i] = Tmp;  }
 }

提交结果为原始希尔排序的结果

Part 4：堆排序

定理：堆排序处理N个不同元素的 随机排列的平均比较次数是 2NlogN-O(NloglogN) 。
虽然堆排序给出最佳平均时间复杂度，但实际效果不如用 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++;  /* Child指向左右子结点的较大者 */        
    if( X >= A[Child] ) break; /* 找到了合适位置 */        
    else  /* 下滤X */            
    A[Parent] = A[Child];    }    
    A[Parent] = X;
 } 
 void HeapSort( 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 );     }
   }

Part 5：归并排序 T(N)=O(NlogN)

递归版：

/* 归并排序 - 递归实现 */ /* 
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 MergeSort( 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( "空间不足" );
 }

非递归版：

/* 归并排序 - 循环实现 *//* 这里Merge函数在递归版本中给出 */
 /* 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 ) /* 归并最后2个子列*/        
      Merge( A, TmpA, i, i+length, N-1);     
      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 = malloc( N * sizeof( ElementType ) );     
     if ( TmpA != NULL ) {          
         while( length < N ) {              
         Merge_pass( A, TmpA, N, length );              
         length *= 2;              
         Merge_pass( TmpA, A, N, length );  /*如果已经有Merge里面复制到A[i]的代码，是否不需要重复这一代码？*/            
         length *= 2;          }          
         free( TmpA );   }
     else printf( "空间不足" );
 }