归并排序

《算法导论》第3版2.3设计算法里提到

我们将用分治法来设计一个排序算法
该算法的最坏情况运行时间比插入排序要少得多

1. 归并排序（设置哨兵）

《算法导论》第3版2.3.1分治法里提出了归并排序的算法

归并排序算法完全遵循分治模式
1）分解：分解待排序的n个元素的序列成各具n/2个元素的两个子序列
2）解决：使用归并排序递归地排序两个子序列
3）合并：合并两个已排序的子序列以产生已排序的答案

设置哨兵，它不可能为较小值

void mergeWithSentry(int A[], int left, int mid, int right)
{
    int n1 = mid - left + 1;
    int n2 = right - mid;

    int *L = new int[n1 + 1];
    int *R = new int[n2 + 1];

    for (int i = 0; i < n1; ++i)
        L[i] = A[left + i];
    for (int j = 0; j < n2; ++j)
        R[j] = A[mid + 1 + j];

    L[n1] = INT_MAX;
    R[n2] = INT_MAX;

    int i = 0, j = 0;

    int k = left;
    while (k <= right)
    {
        if (L[i] <= R[j])
            A[k++] = L[i++];
        else
            A[k++] = R[j++];
    }

    delete L;
    L = NULL;

    delete R;
    R = NULL;
}

void merge_sort(int A[], int left, int right)
{
    if (left < right)
    {
        int mid = left + (right - left) / 2;
        merge_sort(A, left, mid);
        merge_sort(A, mid + 1, right);
        // mergeWithSentry(A, left, mid, right);
        mergeWithoutSentry(A, left, mid, right);
    }
}

2. 归并排序（不使用哨兵）

《算法导论》第3版习题2.3-2提出
重写过程merge，使之不使用哨兵，而是一旦数组L或R的所有元素均被复制回A就立刻停止，然后把另一个数组的剩余部分复制回A。

void mergeWithoutSentry(int A[], int left, int mid, int right)
{
    int n1 = mid - left + 1;
    int n2 = right - mid;

    int *L = new int[n1];
    int *R = new int[n2];

    for (int i = 0; i < n1; ++i)
        L[i] = A[left + i];
    for (int j = 0; j < n2; ++j)
        R[j] = A[mid + 1 + j];

    int i = 0, j = 0;
    int k = left;
    while (i < n1 && j < n2)
    {
        if (L[i] <= R[j])
            A[k++] = L[i++];
        else
            A[k++] = R[j++];
    }

    while (i < n1)
        A[k++] = L[i++];
    while (j < n2)
        A[k++] = R[j++];

    delete L;
    L = NULL;

    delete R;
    R = NULL;
}

void merge_sort(int A[], int left, int right)
{
    if (left < right)
    {
        int mid = left + (right - left) / 2;
        merge_sort(A, left, mid);
        merge_sort(A, mid + 1, right);
        // mergeWithSentry(A, left, mid, right);
        mergeWithoutSentry(A, left, mid, right);
    }
}

3. 总结

注意不要对L和R数组的长度计算错误
不要遗漏对L和R数组的初始化，以及初始化时的下标
注意k的取值范围不要和i,j的取值范围混淆
记得不要遗漏i,j,k的自增、在什么时候自增
设置哨兵：注意不要遗漏哨兵的设置
不使用哨兵：注意L或R数组是否未遍历完，若有剩余元素注意不能遗漏

4. 简化写法

void merge(int A[], int left, int mid, int right, int temp[])
{
    int i = left, j = mid + 1;
    int k = left;

    while (i <= mid && j <= right)
    {
        if (A[i] <= A[j])
            temp[k++] = A[i++];
        else
            temp[k++] = A[j++];
    }

    while(i <= mid)
        temp[k++] = A[i++];
    while (j <= right)
        temp[k++] = A[j++];

    // 注意 i <= right 不要写成 i < right
    for (int i = left; i <= right; ++i)
        A[i] = temp[i];
}


void merge_sort(int A[], int left, int right, int temp[])
{
    if (left < right)
    {
        int mid = left + (right - left) / 2;
        merge_sort(A, left, mid, temp);
        merge_sort(A, mid + 1, right, temp);
        merge(A, left, mid, right, temp);
    }
}