合并排序

合并排序：把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

效率：⊙(nlogn)

 伪代码：

Mergesort(A[0..n-1])
//递归调用mergesort来对数组A[0..n-1]排序
//输入：一个可排序数组A[0..n-1]
//输出：非降序排列的数组A[0..n-1]
if n>1
    copy A[0..[n/2]-1] to B[0..[n/2]-1]
    copy A[[n/2]..n-1] to C[0..[n/2]-1]
    Mergesort(B[0..[n/2]-1]
    Mergesort(C[0..[n/2]-1]
    Merge(B,C,A)

Merge(B[0..p-1],C[0..q-1],A[0..p+q-1])
//将两个有序数组合并为一个有序数组
//输入：两个有序数组B[0..P-1]和C[0..q-1]
//输出：A[0..p+q-1]中已经有序存放了B和C中的元素
i<-0;j<-0;k<-0
while i<p and j<q do
    if B[i]<=C[j]
    else A[k]<-C[j];j<-j+1
    k<-k+1;
    if i=p
         copy C[j..q-1] to A[k..p+1-1]
    else copy B[i..p-1] to A[k..p+q-1]

合并排序代码实现：

result mergeSort(int *intArray,int n){
    if(intArray==NULL||n<0){
        return fail;
    }
    if(n==1){
        return success;
    }
    //分离
    int leftLength=n/2;
    int rightLength=n-leftLength;

    int *leftArray=(int *)malloc(leftLength*sizeof(int *));
    int *rightArray=(int *)malloc(rightLength*sizeof(int *));

    copy(intArray,leftArray,0,0,leftLength);
    copy(intArray,rightArray,leftLength,0,rightLength);


    //子数组排序
    mergeSort(leftArray,leftLength);
    mergeSort(rightArray,rightLength);

    //合并
    merge(leftArray,rightArray,intArray,n);
    return success;
}

result merge(int *leftArray,int *rightArray,int *intArray,int n){
    if(leftArray==NULL||rightArray==NULL||intArray==NULL||n<2){
        return fail;
    }
    int leftLength=n/2;
    int rightLength=n-leftLength;

    int leftIndex=0;
    int rightIndex=0;
    int intIndex=0;

    while(leftIndex<leftLength&&rightIndex<rightLength){
        if(leftArray[leftIndex]<=rightArray[rightIndex]){
            intArray[intIndex]=leftArray[leftIndex];
            leftIndex++;
        }else{
            intArray[intIndex]=rightArray[rightIndex];
            rightIndex++;
        }
        intIndex++;
    }
    if(leftIndex==leftLength){
        copy(rightArray,intArray,rightIndex,intIndex,n-intIndex);
    }else{
        copy(leftArray,intArray,leftIndex,intIndex,n-intIndex);
    }
    return success;
}

void copy(int *sourceArray,int *distArray,int sourceStart,int distStart,int length){
    for(int i=0;i<length;i++){
        distArray[distStart+i]=sourceArray[sourceStart+i];
    }
}

完整代码：

result mergeSort(int *intArray,int n){
     if(intArray==NULL||n<0){
         return fail;
     }
     if(n==1){
         return success;
     }
     //分离
     int leftLength=n/2;
     int rightLength=n-leftLength;
 
     int *leftArray=(int *)malloc(leftLength*sizeof(int *));
     int *rightArray=(int *)malloc(rightLength*sizeof(int *));
 
     copy(intArray,leftArray,0,0,leftLength);
     copy(intArray,rightArray,leftLength,0,rightLength);
 
 
     //子数组排序
     mergeSort(leftArray,leftLength);
     mergeSort(rightArray,rightLength);
 
     //合并
     merge(leftArray,rightArray,intArray,n);
     return success;
 }
 
 result merge(int *leftArray,int *rightArray,int *intArray,int n){
     if(leftArray==NULL||rightArray==NULL||intArray==NULL||n<2){
         return fail;
     }
     int leftLength=n/2;
     int rightLength=n-leftLength;
 
     int leftIndex=0;
     int rightIndex=0;
     int intIndex=0;
 
     while(leftIndex<leftLength&&rightIndex<rightLength){
         if(leftArray[leftIndex]<=rightArray[rightIndex]){
             intArray[intIndex]=leftArray[leftIndex];
             leftIndex++;
         }else{
             intArray[intIndex]=rightArray[rightIndex];
             rightIndex++;
         }
         intIndex++;
     }
     if(leftIndex==leftLength){
         copy(rightArray,intArray,rightIndex,intIndex,n-intIndex);
     }else{
         copy(leftArray,intArray,leftIndex,intIndex,n-intIndex);
     }
     return success;
 }
 
 void copy(int *sourceArray,int *distArray,int sourceStart,int distStart,int length){
     for(int i=0;i<length;i++){
         distArray[distStart+i]=sourceArray[sourceStart+i];
     }
 }

参考：算法设计与分析基础