归并排序初步

优点

归并排序以O(N log N)为最坏运行时间，而使用的比较次数基本是最优的。他是递归算法的很好实例。

基本思路

归并排序中的基本操作是合并2个已经排好序的表。因为这两个表示是已经排好序的，所以将输出放到第三个表中时则该算法可以通过对输入一趟排序来完成。基本的合并算法是取两个输入数组A 和 B，一个输出数组 C，以及三个计数器 Aptr，Bptr， Cptr，他猛初始位置于对应数组的开始端。A[Aptr] 和 B[Bptr] 中的较小的被拷贝到C中的下一个位置，相关的计数器先前推进一步。当两个输入表有一个用完的时候，则将另一个表的剩余的部分拷贝到C中。合并例程参见下图：

（图片君飞了，自行脑补）

数列A为 1 13 24 26
数列B为 2 15 27 38
数列C有8个空位

现在我们排序数组A B ；
1.首先将Aptr指向A数组的首位，将Bptr指向B数组的首位；
2.判断Aptr 和 Bptr是否在数组的范围内；
3.比较 *Aptr 和 *Bptr 的大小；
4.如例是数组A的第一位写入数组C；
5.Aptr++ 或者 Bptr++；
6.返回2
7.将另一数组中的剩余的数值全部依次复制到C中；

上代码

递推版本

#include<stdio.h>
#include<stdlib.h>
int min(int x, int y) {
    return x < y ? x : y;
}
void merge_sort(int arr[], int len) {
    int* a = arr;
    int* b = (int*)malloc(len * sizeof(int*));
    int seg, start;
    for (seg = 1; seg < len; seg += seg) {
        for (start = 0; start < len; start += seg + seg) {
            int low = start, mid = min(start + seg, len), high = min(start + seg + seg, len);
            int k = low;
            int start1 = low, end1 = mid;
            int start2 = mid, end2 = high;
            while (start1 < end1 && start2 < end2)
                b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
            while (start1 < end1)
                b[k++] = a[start1++];
            while (start2 < end2)
                b[k++] = a[start2++];
        }
        int* temp = a;
        a = b;
        b = temp;
    }
    if (a != arr) {
        int i;
        for (i = 0; i < len; i++)
            b[i] = a[i];
        b = a;
    }
    free(b);
}

递归版本

void merge_sort_recursive(int arr[], int reg[], int start, int end) {
    if (start >= end)
        return;
    int len = end - start, mid = (len >> 1) + start;
    int start1 = start, end1 = mid;
    int start2 = mid + 1, end2 = end;
    merge_sort_recursive(arr, reg, start1, end1);
    merge_sort_recursive(arr, reg, start2, end2);
    int k = start;
    while (start1 <= end1 && start2 <= end2)
        reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
    while (start1 <= end1)
        reg[k++] = arr[start1++];
    while (start2 <= end2)
        reg[k++] = arr[start2++];
    for (k = start; k <= end; k++)
        arr[k] = reg[k];
}
void merge_sort(int arr[], const int len) {
    int reg[len];
    merge_sort_recursive(arr, reg, 0, len - 1);
}

递归版本完美的诠释了上文的思路，其中递归的第1、2次调用是为了将子序列排序，然后将两个已经有序的子序列排成一个序列