归并排序详解

归并排序（MergeSort），正如其名字一样，需要我们先进行递归分解，在来进行合并。
我们的数字以中间位置为界，左边与右边分别是已经排序好的数组，arr为[1, 15, 17, 20, 2, 13, 16, 19]，现在我们将其左边部分视为一个排序好的序列，右边部分视为一个排序好的序列，所以我们可以写出代码：

void MergeArray (int* arr, int left, int mid, int right) 
{
    int* temp = new int[right + 1];
    int i = left, m = mid, j = mid + 1, n = right, k = 0;
    while (i <= m && j <= n) 
    {
        if (arr[i] <= arr[j]) 
            temp[k++] = arr[i++];
        else
            temp[k++] = arr[j++];
    }
    while (i <= m)
        temp[k++] = arr[i++];
    while (j <= n)
        temp[k++] = arr[j++];
    for (int x = 0; x < k; x++) 
        arr[left + x] = temp[x];
    delete[] temp;
}

目前来说我们只是以数组的中间位置作为界限，那么我们在一个无序数组前，是不是也应该先将无序数组分为左右两个部分，分而治之。所以我们可以采用递归的思想来解决这个问题，所以我们可以写出一下代码：

void MSort (int* arr, int left, int right) 
{
    if (left >= right)
        return;
    int mid = (left + right) / 2;
    // sort the left part
    MSort(arr, left, mid);
    // sort the right part
    MSort(arr, mid + 1, right);
    // merge two part
    MergeArray(arr, left, mid, right);
}

但是考虑一下我们现在的代码，我们每进行一次MergeArray就要声明一个数组，这样是不是有点浪费呢？是不是可以将其在外部一次声明好，将这个temp数组作为参数传入MergeArray函数呢？这样又带来了一个问题，那就是函数参数过多，所以我们还需要一个方法，这个方法只接受两个参数，一个是待排序数组，一个是数组的长度，于是可以将我们代码改进，得到如下代码：

void MergeArray (int* arr, int* temp, int left, int mid, int right) 
{
    int i = left, m = mid, j = mid + 1, n = right, k = 0;
    while (i <= m && j <= n) 
    {
        if (arr[i] <= arr[j]) 
            temp[k++] = arr[i++];
        else
            temp[k++] = arr[j++];
    }
    while (i <= m)
        temp[k++] = arr[i++];
    while (j <= n)
        temp[k++] = arr[j++];
    for (int x = 0; x < k; x++) 
        arr[left + x] = temp[x];
}
void MSort (int* arr, int left, int right, int* temp) 
{
    if (left >= right)
        return;
    int mid = (left + right) / 2;
    // sort the left part
    MSort(arr, left, mid, temp);
    // sort the right part
    MSort(arr, mid + 1, right, temp);
    // merge two part
    MergeArray(arr, temp, left, mid, right);
}
void MergeSort (int* arr, int len) 
{
    int* temp = new int[len];
    MSort(arr, 0, len - 1, temp);
    delete[] temp;
}

我们用递归的方法实现了归并排序，但是考虑下我们可不可以不用递归的方法呢？我们可以先将原始序列看成N个只包含1个元素的有序子序列，然后每次迭代归并两个相邻的有序子序列，直到最后只剩下1个有序的序列。这样的话我们利用循环就可以实现。

void Merge (int* arr, int* temp, int left, int mid, int right, int* arr2)
{
    int i = left, m = mid, j = mid, n = right, k = 0;
    while (i < m && j < n) {
        if (arr[i] <= arr[j])
            temp[k++] = arr[i++];
        else
            temp[k++] = arr[j++];
    }
    while (i < m)
        temp[k++] = arr[i++];
    while (j < n)
        temp[k++] = arr[j++];
    for (int i = 0; i < k; i++)
        arr[left + i] = temp[i];
    cout<<'\n';
}
void MergeSort (int* arr, int len)
{
    int* temp = new int[len];
    for (int i = 1; i < len; i *= 2) {
        // i is the length of already sort child list
        for (int j = 0; j < len; j += 2 * i) {
            if (j + 2 * i <= len)
                Merge(arr, temp, j, j + i, j + 2 * i);
            else if (j + 2 * i > len && j + i <= len)
                Merge(arr, temp, j, j + i, len);
        }
    }
    delete[] temp;
}