归并排序用例

思路

一眼看懂怎么排序的把

1.首先申请额外的空间用于放置归并的结果，接着设置两个指针分别指向两个已排序子序列的第一个位置，
2.然后比较两个指针指向的元素，将较小的元素放置到已申请的额外空间内，并将当前位置向后移动一格，
3.重复以上过程，直到某一个子序列的指针指向该序列的结尾，这时候将另一个指针所指向的剩余元素全部放置到额外空间内，归并操作结束。

递归代码

//归并排序
#include<stdio.h>
#include<stdlib.h>
typedef int ElementType;
void Print_Array(ElementType A[],int N)
{
	printf("\n");
	for(int i=0;i<N;i++)
		printf("%d ",A[i]);
}

/* 归并排序 - 递归实现 */
/* 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( "空间不足" );
}
int main()
{
	int arr[8] = {5,3,1,6,2,9,7,4};
	Print_Array(arr,8);
	Merge_Sort(arr,8);
	Print_Array(arr,8);
	return 0;
}

非递归代码

把临时数组和A倒来倒去，节约空间

//归并排序循环版本
#include<stdio.h>
#include<stdlib.h>

typedef int ElementType;
void Print_Array(ElementType A[],int N)
{
	printf("\n");
	for(int i=0;i<N;i++)
		printf("%d ",A[i]);
}
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 Merge_pass( ElementType A[], ElementType TmpA[], int N, int length )/*length是有序子列长度，一开始等于1，每个数组就是一个子序列*/
{ /* 两两归并相邻有序子列 */
     int i, j;
       
     for ( i=0; i <= N-2*length; i += 2*length )
         Merge( A, TmpA, i, i+length, i+2*length-1 );/*A倒去tmpA*/
     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 );/*把tmpA倒回A*/
          length *= 2;
          }
          free( TmpA );
     }
     else printf( "空间不足" );
} 


int main()
{
	int arr[8] = {5,3,1,6,2,9,7,4};
	Print_Array(arr,8);
	Merge_Sort(arr,8);
	Print_Array(arr,8);
	return 0;
	
}

总结

归并排序缺点：浪费空间，适合外排
归并稳定