排序算法（四）——归并排序

---

简介

1. 什么是归并排序？
   归并排序就是将有n个记录的数据看做n个子序列，两个两个进行排序，然后合并，如此往复，直到形成n个记录的有序序列。这叫做2路归并排序。

2. 归并排序和希尔排序？
   归并排序将每次进行比较的子序列长度从1逐渐增加到n/2附近；
   希尔排序将每次进行比较的子序列长度从n/3+1逐渐降低到1.
   二者的算法复杂度都是O(nlogn)。具体来说，前者为O(nlog2n)，后者为O(nlog3n).

---

提示：以下是本篇文章正文内容，下面案例可供参考

递归归并排序

代码如下：

#include <iostream>
using namespace std;
#define MAXSIZE 13
void merging(int *list1, int list1_size, int *list2, int list2_size)
{
    int i = 0, j = 0, k = 0;
    int tmp[MAXSIZE];
    while(i < list1_size and j < list2_size)
    {
        if (list1[i] < list2[j])
        {
            tmp[k++] = list1[i++];
        }
        else
        {
            tmp[k++] = list2[j++];
        }
    }
    while(i < list1_size)
        tmp[k++] = list1[i++];
    while (j < list2_size)
        tmp[k++] = list2[j++];
    for (int m = 0; m < (list1_size+list2_size); m++)
        list1[m] = tmp[m];
}
void MergeSort(int k[], int n)
{
    if (n > 1)
    {
        int *list1 = k;
        int list1_size = n/2;
        int *list2 = k + n/2;
        int list2_size = n - list1_size;
        MergeSort(list1, list1_size);
        MergeSort(list2, list2_size);
        merging(list1, list1_size, list2, list2_size);
    }
    for (int i = 0; i < n; i++)
        cout << k[i] << " ";
    cout << endl;
}
int main()
{
    int k[] = {2, 1, 5, 7, 5, 6, 10, 20, 15, 17, 16, 14, 13};
    MergeSort(k, 13);
    return 0;
}

运行结果如下：

1 2 5 5 6 7 10 13 14 15 16 17 20

迭代归并排序

代码如下：

#include <iostream>
using namespace std;
#define MAXSIZE 13
void MergeSort(int k[], int n)
{
    for (int i = 1; i <= n; i *= 2)
    {
        int left_min, left_max, right_min, right_max;
        int *tmp = (int*)malloc(MAXSIZE* sizeof(int));
        for (int begin = 0; begin < n-i; begin += 2*i)
        {
            left_min = begin;
            left_max = left_min + i;
            right_min = left_max;
            right_max = right_min + i;
            if (right_max > n)
                right_max = n;
            int next = 0;
            while (left_min < left_max and right_min < right_max)
            {
                if (k[left_min] < k[right_min])
                    tmp[next++] = k[left_min++];
                else
                    tmp[next++] = k[right_min++];
            }
            while (left_min < left_max)
                k[--right_min] = k[--left_max];
     	    while (next > 0)
            {
                k[--right_min] = tmp[--next];
            }
        }
        cout << "i：" << i << "  ";
        for (int i = 0; i < n; i++)
            cout << k[i] << " ";
        cout << endl;
    }
    cout << "final:";
    for (int i = 0; i < n; i++)
        cout << k[i] << " ";
    cout << endl;
}
int main()
{
    int k[] = {2, 1, 5, 7, 5, 6, 10, 20, 15, 17, 16, 14, 13};
    MergeSort(k, 13);
    return 0;
}

其中需要说明的是最后两个while，相当于实现了一段数据间的交换。
举例来说，如果进行比较的数据为1， 2， 3， 4，那么这段数据不需要进行交换；
如果数据为3， 4， 1， 2，tmp中存储的是1， 2，那么第一个while是将数据变成3，4，3，4，第二个while将数据变为1，2，3，4.
如果数据为2，3，1，4，tmp中存储的是1，2，3，那么不执行第一个while，第二个while将数据变为1，2，3，4.

运行结果为：

i:1  1 2 5 7 5 6 10 20 15 17 14 16 13
i:2  1 2 5 7 5 6 10 20 14 15 16 17 13
i:4  1 2 5 5 6 7 10 20 13 14 15 16 17
i:8  1 2 5 5 6 7 10 13 14 15 16 17 20
final:1 2 5 5 6 7 10 13 14 15 16 17 20

---

总结

神使用递归，人使用迭代。