C语言实现归并排序

依照《算法导论》中的描述编写归并排序代码

归并排序算法完全遵循分治模式：

• 分解：分解待排序的n个元素的序列成各具n/2个元素的两个子序列。

• 解决：使用归并排序递归地排序两个子序列。

• 合并：合并两个已排序的子序列以产生已排序的答案。

伪代码：

//对分组归并
MERGE(A, p, q, r)
    n1 = q-p+1
    n2 = r-q
    let L[1....n1+1] and R[1....n2+1] be new arrays
    for i =1 to n1
         L[i] = A[p+i-1]
    for j=1 to n2
        R[j] = A[q+j]
    L[n1+1] = ∞
    L[n2+1] = ∞
    i=1
    j=1
    for k =p to r
        if L[i]<=R[j]
            A[k] = L[i]
            i = i + 1
        else
            A[k]=R[j]
            j = j+1

//归并排序
MERGE-SORT(A,p,r)
    if p < r
        q =⌊(p+r)/2⌋
        MERGE-SORT(A, p, q)
        MERGE-SORT(A, q+1, r)
        MERGE(A, p, q, r)

C语言实现：

//使用C语言实现归并排序
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

//对分组归并
//假设子数组A[p..q]和A[q+1..r]都已排好序，合并这两个子数组形成单一的已排好序的子数组并代替当前的子数组A[p..r]
//待合并元素的总数是n=r-p+1
void merge(int A[], int p, int q, int r) {
    int n1 = q - p + 1;
    int n2 = r - q;
    int i, j;
    //C语言不允许使用变量初始化数组，可以使用malloc+memset或者直接calloc（推荐）的方法。
    int* L = (int*)calloc(n1 + 1, sizeof(int));
    int* R = (int*)calloc(n2 + 1, sizeof(int));
    for (i = 0; i < n1; i++)
        L[i] = A[p + i];
    for (j = 0; j < n2; j++)
        R[j] = A[q + j + 1];
    //设置哨兵
    L[n1] = _CRT_INT_MAX;
    R[n2] = _CRT_INT_MAX;
    i = j = 0;
    for (int k = p; k <= r; k++) {
        //从L、R数组中取更小的元素插入A数组
        if (L[i] <= R[j]) {
            A[k] = L[i];
            i++;
        }
        else {
            A[k] = R[j];
            j++;
        }
    }
    free(L);
    free(R);
}

//归并排序
void mergeSort(int A[], int p, int r) {
    //若不满足下面的if条件，则跳出当前递归返回上一层
    if (p < r) {
        int q = (int)floor(((double)p + r) / 2.0);
        mergeSort(A, p, q);
        mergeSort(A, q + 1, r);
        merge(A, p, q, r);
    }
}

main(){
	//测试
    int A[] = { 5,2,4,7,1,3,2,6 };
    mergeSort(A, 0, 7);
    for (int i = 0; i < 8; i++)
        printf("%d ", A[i]);
}

若对递归过程不太了解，建议在IDE中使用调试模式跑一遍代码。

递归树及时间复杂度分析：

通过将T(n)分解成由递归式所确定的它的组成部分来继续扩展树中的每个结点，直到问题规模下降到1，每个子问题只要代价c。

在(d)部分，完全扩展了的递归树具有lgn+1层（如图所示，其高度为lgn），每层将贡献总代价cn。所以总代价为cnlgn+cn，它就是Θ(nlgn)