归并排序

归并排序

核心： 有序子列的归并

T（N) = O(N)

递归采用分治算法

T(N) = T(N/2) + T(N/2) + O(N) -> T(N) = T(NlogN)

如果只在Merge中申请临时数组 会频繁申请释放空间 将耗费O(NlogN)的额外空间

所以只申请一个临时空间 只在临时空间的一段做操作 额外空间复杂度将保持O(N)

特点：

稳定 平均时间复杂度O(Nlog2N) 最坏时间复杂度O(Nlog2N) 额外空间复杂度O(N)

适合外部排序

代码：

#include <stdio.h>
#include <stdlib.h>

//归并函数
//将有序的A[L]~A[R-1]和A[R]~A[RightEnd]归并成一个有序序列
void Merge(ElementType A[], ElementType TmpA[], int L, int R, int RightEnd)
{
    int LeftEnd, NumElements, Tmp;
    int i;

    LeftEnd = R-1;
    NumElements = RightEnd - L + 1;
    Tmp = L;  //临时数组指针

    while (L <= LeftEnd && R <= RightEnd) {
        if (A[L] <= A[R])
            TmpA[Tmp++] = A[L++];
        else
            TmpA[Tmp++] = A[R++];
    }

    //复制剩余部分
    while (L <= LeftEnd)
        TpmA[Tmp++] = A[L++];
    while (R <= RightEnd)
        TmpA[Tmp++] = A[R++];

    //TmpA复制回A
    for (i = 0; i < NumElements; i++, RightEnd--)
        A[RightEnd] = TmpA[RightEnd];
}

//分治思想 核心递归排序函数
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("空间不足");
}