归并排序-循环实现

归并排序是建立在归并操作基础上的一种排序方法。归并操作，是指将两个已排序的子序列合并成一个有序序列的过程

归并操作的过程如下：

1. 申请额外空间用于放置两个子序列归并后的结果
2. 设置两个指针分别指向两个已排子序列的第一个位置
3. 比较两个指针指向的元素，并将较小的那个放到1中申请的空间内，当前指针向后移动一格
4. 重复3，直到某个子序列的指针指向该序列的结尾
5. 将另一序列剩余元素全部放入到1中空间内，归并操作结束

/* 归并排序 - 循环实现 */
/* 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[] */
}

/* length = 当前有序子列的长度*/
void Merge_pass( ElementType A[], ElementType TmpA[], int N, int length )
{ /* 两两归并相邻有序子列 */
     int i, j;
     //i<=N-2*length，因为归并到最后，两个有序序列的尾巴长度不一，要单独处理
     for ( i=0; i <= N-2*length; i += 2*length )
         Merge( A, TmpA, i, i+length, i+2*length-1 );//i+length意味着是右子序列的开始
     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 );
              length *= 2;
          }
          free( TmpA );
     }
     else printf( "空间不足" );
}

归并算法是一个稳定的排序算法，并且它的时间复杂度不高，每一趟归并操作都需要O(N)次比较，一共需要进行O(logN)次归并，所以归并排序的时间复杂度是O(NlogN)。相对于快排和堆排序，归并排序虽然消耗更多的空间，但整体的排序过程是稳定的。

归并的弊端在于，开辟大块的额外空间并将两个数组来回复制是非常耗时的，所以他一般不会用于内部排序（在内存内就可以完成的排序），但他在外部排序，分布式计算上非常有用。