第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替换#defineconst 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次。

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