第2篇 归并排序

归并排序

归并思想：将两个有序的数组归并成一个更大的有序数组。

优点：保证将任意长度N的数组排序所需时间和NlogN成正比。

缺点：所需的额外空间和N成正比。

1 原地归并的抽象方法

所谓原地归并，既是将连个已经有序的子序列合并为一个序列。

/*
 *需要额外的数组大小的空间
 *主要是对四种情况的比较：
 *1.左半边用尽
 *2.右半边用尽
 *3.右半边当前元素小于当前元素
 *4.右半边当前元素大于当前元素
 */
void Merge(int *a, int low, int mid, int high){
    //将a中的元素都复制到aux中去。
    for (int k = low; k <= high; ++k)
        aux[k] = a[k];
    //再将aux中的元素排序到a中
    int i = low;
    int j = mid + 1;
    for (int k = low; k <= high; ++k){
        if (i > mid)
            a[k] = aux[j++];
        else if (j > high)
            a[k] = aux[i++];
        else if (aux[j] < aux[i])   //这里一开始写成(a[j] < a[i]),调试了1个小时，打脸！！！
            a[k] = aux[j++];
        else
            a[k] = aux[i++];
    }
}

2 自顶向下的归并排序

对于N个数据来讲，划分为n层，对于0~n-1之间的任意k，自顶向下第k层有2的k次方个数组，每个数组长度为2的(n-k)次方，归并最多需要2的(n-k)次比较，因此，每层的比较次数为2的n次方，n层总共为n*2的n次 = NlgN。

下面给出测试例子：

#include <iostream>
using namespace std;

typedef void(*Fp)(int *a, int count);

//根据<<Effective C++>> 条款02 ： 尽量使用const,enum,inline替换#define
const int Count = 10;
int aux[Count];

//原地归并的抽象方法
void Merge(int *a, int low, int mid, int high);
//自顶向下的归并排序
void merge_sort(int *a, int count);

void _merge_sort(int *a, int low, int high);

int main()
{
    int a[] = { 23, 3, 45, 123, 2, 1, 342, 52, 452, 22 };
    //排序前：
    cout << "排序前：" << endl;
    for (int i = 0; i < Count; ++i)
        cout << a[i] << " ";
    cout << endl;

    Fp fp = merge_sort;

    fp(a, Count);

    //排序后：
    cout << "排序后：" << endl;
    for (int i = 0; i < Count; ++i)
        cout << a[i] << " ";
    cout << endl;

    return 0;
}


/*
 *需要额外的数组大小的空间
 *主要是对四种情况的比较：
 *1.左半边用尽
 *2.右半边用尽
 *3.右半边当前元素小于当前元素
 *4.右半边当前元素大于当前元素
 */
void Merge(int *a, int low, int mid, int high){
    //将a中的元素都复制到aux中去。
    for (int k = low; k <= high; ++k)
        aux[k] = a[k];
    //再将aux中的元素排序到a中
    int i = low;
    int j = mid + 1;
    for (int k = low; k <= high; ++k){
        if (i > mid)
            a[k] = aux[j++];
        else if (j > high)
            a[k] = aux[i++];
        else if (aux[j] < aux[i])   //这里一开始写成(a[j] < a[i]),调试了1个小时，打脸！！！
            a[k] = aux[j++];
        else
            a[k] = aux[i++];
    }
}

void merge_sort(int *a, int count){
    _merge_sort(a, 0, count - 1);
}

void _merge_sort(int *a, int low, int high){
    //首先判断是否只有1个元素
    if (high <= low)
        return;
    int mid = low + (high - low) / 2;
    //归并的排列左半边
    _merge_sort(a, low, mid);
    //归并的排列右半边
    _merge_sort(a, mid + 1, high);
    //将两边合并
    Merge(a, low, mid, high);
}

这种排序是高效算法设计中分治思想最典型的一个例子。

下面给出几种性质：

1）对于长度为N的任意数组，自顶向下的归并排序需要1/2NlgN至NlgN次比较。

2）对于长度为N的任意数组，自顶向下的归并排序最多需要访问数组6NlgN次。

对于自顶向下的归并排序有以下几点可以优化的地方：

1）对于小规模子数组使用插入排序（比如长度小于15，一般可以将时间缩短10%到15%）。

2）测试数组是否已经有序。（如果a[mid]小于等于a[mid+1]，就认为数组已经是有序的并跳过merge()方法）。

3）不将元素复制到辅助数组（时间、空间不行）。

3 自底向上的归并排序

先上源码：

void mergeBU_sort(int *a, int count){
    int end = 0;
    for (int sz = 1; sz < Count; sz = sz + sz){                     //sz表示子数组的大小
        for (int lo = 0; lo < Count - sz; lo += sz + sz){           //lo：子数组的索引
            end = (lo + sz + sz - 1) < (Count - 1) ? (lo + sz + sz - 1) : (Count - 1);
            Merge(a, lo, lo + sz - 1, end);
        }
    }
}

思想：首先进行两两归并，然后四四归并，然后八八归并。。。

对于长度为N的任意数组，自底向上的归并排序需要1/2NlgN至NlgN次比较，最多访问数组6NlgN次。

优势：自底向上的归并排序比较适合用链表组织的数据。