归并排序

归并排序的核心思想是将两个已经排序的序列合并成一个序列，那如何得到两个已经排序的序列呢？我们知道， 如果一个序列只有一个元素，那该序列是已经排序的，这样我们就可以利用分治的思想，将未排序的序列划分成更小的序列，只到我们可以很方便的对小序列进行排序（比如划分到序列只有一个元素， 或者序列很小可以方便的使用其它排序算法进行排序），然后再将小序列逐次合并，得到最后的排序结果。

实现：

/*
 * @brief 将两个已排序的序列 in[l...m]和in[m+1...r]合并,放入out中
 * num 为计算逆序对所用
 */
int num = 0;
void merge(int in[], int out[], int l, int m, int r)
{
    int i = l;
    int k  = m + 1;

    while (l <= m && k <= r) {
        if (in[l] <= in[k]) {
            out[i++] = in[l++];
        } else {
            out[i++] = in[k++];
            /* 因为此时in[l...m]已经排序，如果in[l] 与 in[k] 逆序,
                则in[l+1], in[l+2]...in[m] 都与in[k]逆序, 共 m-l+1 对*/
            num += m - l + 1; /* calculate the inversion number */
        }
    }
    while (l <= m) {
        out[i++] = in[l++];
    }
    while (k <= r) {
        out[i++] = in[k++];
    }
}

/*
 * @brief 递归将序列划分为只有一个元素的子序列, 然后逐次对子序列进行合并
 */
void m_sort(int in[], int out[], int l, int r)
{
    /* 仅有一个元素, 已排序, 递归结束 */
    if (l >= r) {
        return;
    }

    /* 计算 l 和 r 的中间值, 防止溢出 */
    int m = (l & r) + ((l ^ r) >> 1);
    /* note that in and out are swapped */
    m_sort(out, in, l, m);
    m_sort(out, in, m + 1, r);

    merge(in, out, l, m, r);
}

/*
 * @brief merge sort
 * 统一申请空间, 避免反复申请释放
 */
int merge_sort(int a[], int n)
{
    int *b = (int *)malloc(n * sizeof(int));
    if (b) {
        memcpy(b, a, n * sizeof(int));
        m_sort(b, a, 0, n - 1);
        free(b);
        return 0;
    }

    return -1;
}