归并排序

 

 

 

时间复杂度： #

 

 

 

/* 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 OriginalL = L;    //记录L的初始位置，以便于最后将TmpA[]复制回A[]
    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 */
            ++Tmp;
            ++L;
        }
        else
        {
            TmpA[Tmp] = A[R];     /* 将右边元素复制到TmpA */
            ++Tmp;
            ++R;
        }
    }

    while(L <= LeftEnd)
    {
        TmpA[Tmp] = A[L];         /* 复制左边剩下的 */
        ++Tmp;
        ++L;
    }
    while(R <= RightEnd)           /* 复制右边剩下的 */
    {
        TmpA[Tmp] = A[R];
        ++Tmp;
        ++R;
    }

    for(i = OriginalL; i < NumElements; ++i)
        A[i] = TmpA[i];      /* 将有序的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));

    Msort(A, TmpA, 0, N-1);
    free(TmpA);
}

 

 #

注意：#

在MergeSort中定义TmpA临时数组，可以使整个过程只申请释放空间一次，空间复杂度为O(N) ,如果在Merge函数里定义TmpA数组的话，整个过程将反复malloc与free，使得空间复杂度变为O( NlogN)。