[C语言][排序（4）]归并排序

1.递归版本的归并排序

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( "空间不足" );
}

2.非递归的归并排序

void merge(int a[],int tmpa[],int L,int R,int RightEnd)
{
    int Num,LeftEnd,i,k;
    LeftEnd=R-1;
    Num=RightEnd-L+1;
    k=L;
    while(L<=LeftEnd&&R<=RightEnd)
    {
        if(a[L]<=a[R]) tmpa[k++]=a[L++];
        else           tmpa[k++]=a[R++];
    }
    while(L<=LeftEnd)
    {
        tmpa[k++]=a[L++];
    }
    while(R<=RightEnd)
    {
        tmpa[k++]=a[R++];
    }
}
void merge_pass(int a[],int 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);
    }
    else
    {
        for(j=i;j<n;j++)
            tmpa[j]=a[j];
    }
}
void merge_sort(int a[],int n)
{
    int *tmpa;
    tmpa=(int*)malloc(n*sizeof(int));
    int length=1;
    while(length<n)
    {
        merge_pass(a,tmpa,n,length);
        length=length*2;
        merge_pass(tmpa,a,n,length);
        length=length*2;
    }
}

非递归的方法同样用了额外的O(n)空间，但是要比递归的方法巧妙。第一轮，将数组a的每一个元素看作一个单独的有序序列，然后将其合并，按顺序放在数组tmpa中，然后length*2，第二轮：将每两个看作一个有序序列，按序合并放在数组a中，依次合并，直到最后。最后保证了将元素放回a中，因为就算前一轮有序了，后面一波还是会进行。