高级排序算法（一）

O(nlogn)的排序算法

我们先来看看nlogn比n²快多少？

归并排序（Merge Sort）

算法思想：假定待排序表含有n个记录，递归地将前半部分记录和后半部分记录各自归并，得到排序后的两部分记录，然后在使用合并算法将这两部分合并在一起。

算法演示：

归并排序

基本代码如下：

// 合并算法，将arr[l...mid]和arr[mid+1...r]两部分进行归并
template<typename T>
void __merge(T arr[], int l, int mid, int r) {

    T aux[r - l + 1];
    for (int i = l; i <= r; i++)
        aux[i - l] = arr[i];

    int i = l, j = mid + 1;
    for (int k = l; k <= r; k++) {
        if (i > mid) {
            arr[k] = aux[j - l];
            j++;
        } else if (j > r) {
            arr[k] = aux[i - l];
            i++;
        } else if (aux[i - l] < aux[j - l]) {
            arr[k] = aux[i - l];
            i++;
        } else {
            arr[k] = aux[j - l];
            j++;
        }
    }
}

// 递归使用归并排序，对arr[l...r]的范围进行排序
template<typename T>
void __mergeSort(T arr[], int l, int r) {

    if (l >= r)
        return;
    int mid = (l + r) / 2;
    __mergeSort(arr, l, mid);
    __mergeSort(arr, mid + 1, r);
    __merge(arr, l, mid, r);
}

template<typename T>
void mergeSort(T arr[], int n) {

    __mergeSort(arr, 0, n - 1);
}

那我们在main()中调用mergeSort()，以及我们之前学习过的排序算法，这里就不在演示如何添加代码了。前面介绍4种基本排序算法时，已经清楚介绍了如何添加代码，如若忘记请查看之前的排序基础文章。好了，我们运行我们的程序，看看运行结果吧，结果如下：

Merge Sort : 0.012 s
Insertion Sort : 2.121 s
Shell Sort : 0.014 s

按照我们之前的惯例，此次运行结果是在处理随机数据的情况下得出来的，但这次我们将数据规模调整到了50000个随机数据。我们可以明显发现在处理大规模随机数据下归并排序的效率如此之高。

接着我们来看看在近乎有序的随机数据的情况下，我们的归并排序是否能保持这种高效率呢？结果如下：

Merge Sort : 0.008 s
Insertion Sort : 0.002 s
Shell Sort : 0.011 s

从结果中发现，我们的归并排序仍然能保持高效地处理近乎有序的数据。但我们再回顾一下归并排序的代码，不知有没有发现我们的代码中仍有不足之处？不如我们先看看优化后的代码：

// 递归使用归并排序，对arr[l...r]的范围进行排序
template<typename T>
void __mergeSort(T arr[], int l, int r) {

    if (r - l <= 15) {
        __insertionSort(arr, l, r);
        return;
    }
    int mid = (l + r) / 2;
    __mergeSort(arr, l, mid);
    __mergeSort(arr, mid + 1, r);
    if (arr[mid] > arr[mid + 1])
        __merge(arr, l, mid, r);

当我们待排序的数据较少时，我们可以将排序转变为插入排序。虽然插入排序是时间复杂度为O(n²)的排序算法，但在处理小规模数据时其效率还是较高的。此处的插入排序算法源码如下：

template<typename T>
void __insertionSort(T arr[], int l, int r) {

    for (int i = l + 1; i <= r; i++) {
        // 寻找元素arr[i]合适的插入位置

        T e = arr[i];
        // j保存元素e应该插入的位置
        int j;
        for (j = i; j > l && arr[j - 1] > e; j--) {
            arr[j] = arr[j - 1];
        }
        arr[j] = e;
    }
    return;
}

还有一处优化就是我们增加了一个if判断，为什么要增加这个判断呢？因为，我们若要进行合并排序操作都是在arr[mid] > arr[mid + 1]的情况下。如若arr[mid] <= arr[mid + 1]则已说明待排序已经有序了，无需再进行合并排序操作了。

好了让我们看看优化后的运行结果吧（近乎有序的数据）：

Merge Sort : 0.003 s
Insertion Sort : 0.001 s
Shell Sort : 0.006 s

上述归并排序都是使用了自顶向下的递归实现进行排序，现在我们来看看使用递归实现自底向上的归并排序。

（2-路归并排序）算法思想：假定待排序表含有n个记录，则可以看成是n个有序的子表，每个子表长度为1，然而两两归并，得到「n/2」个长度为2或1的有序表；再两两归并，······如此重复，直到合并成一个长度为n的有序表为止。

算法演示：

归并排序

基本代码如下：

template<typename T>
void mergeSortBU(T arr[], int n) {

    for (int sz = 1; sz <= n; sz += sz) {
        for (int i = 0; i + sz < n; i += sz + sz) {
            // 对arr[i...i+sz-1]和arr[i+sz...i+sz*2-1]进行合并
            __merge(arr, i, i + sz - 1, min(i + sz + sz - 1, n - 1));
        }
    }
}

归并部分我们采用之前的__merge()。好了，我们在main()中调用一下吧，其运行结果如下（随机数据）：

Merge SortBU : 0.013 s