合并排序的思想与实现

合并排序算法是用分治策略实现对N个元素进行排序的算法。

基本思起是 ： 将待排序元素分成大小大致相同的两个子集合，分别对两个子集合进行排序，最终将排好序的子集合合并成所要求的排好序的集合。

大致过程如下图所示：

 该算法的复杂度是 O(nlogn).而最基础的冒泡和选择排序算法复杂度是O（n^2).

 该算法有递归和非递归两种实现：

递归实现：

算法实现过程与上图所示过程相同，先分，后合。

#include <iostream>
using namespace std;

//将a[left..mid]与a[mid+1..right]合并
//a[left..mid]与a[mid+1..right]都是内部升序
void Merge(int a[],int left,int mid,int right){
    int k = 0;
    int i = left,j = mid + 1;
    int b[right -left + 1];//新的数组存放合并后的有序数组
    while(i <= mid && j <= right){
        //将两部分合并，取较小的数放在新数组前面
        if(a[i] <= a[j]){
            b[k++] = a[i++];
        }
        else{
            b[k++] = a[j++];
        }
    }
    //处理合并完后还有剩余的那个部分，因为该部分内部已经有序所以直接拷贝过来
    //因为合并的条件是两部分都未到达尾部，所以可能会有一个部分剩余数
    while( i < mid + 1){
        b[k++] = a[i++];
    }
    while( j < right + 1){
        b[k++] = a[j++];
    } 
    //将b[0..k-1] 复制到 a[left..right]
    //复制完a[left..right]有序
    int m = 0;
    int n = left;
    for( m = 0,n = left; m < k && n <= right; ++m,++n){
        a[n] = b[m];
    }
};

void MergeSort(int a[],int left,int right){
    if(left < right){
        int mid = left + (right - left)/2;//将left...right 分成两部分
        MergeSort(a,left,mid);//执行完后a[left..mid]升序
        MergeSort(a,mid+1,right);//执行完后a[mid+1..right]升序
        Merge(a,left,mid,right);//合并完后a[left..right]升序
    }
    else{
        cout<<"exiting when left = "<<left<<"right = "<<right<<endl;
    }   
};

int main()
{
    int x[] ={1,3,5,2,4,6,8,3};
    MergeSort(x,0,7);
    for (int i = 0; i < 8; ++i){
        cout<<x[i]<<"  ";
    } 
	while(true);
	return 0;
}

非递归实现：

这种实现过程省略了直接从上图所示中间部分往下走运行，没有分的过程。

该算法先将数组中相邻元素两两配对，用合并算符将他们排序，构成(假设数组长度为n) n/2组长度为2的子数组，然后再将他们排序成长度为4子数组段，以此类推直到整个数组排好序。算法实现如下：

#include <iostream>
using namespace std;
//将a[left..mid]与a[mid+1..right]合并
//a[left..mid]与a[mid+1..right]都是内部升序
void Merge(int a[],int left,int mid,int right){
    int k = 0;
    int i = left,j = mid + 1;
    int b[right -left + 1];//新的数组存放合并后的有序数组
    while(i <= mid && j <= right){
        //将两部分合并，取较小的数放在新数组前面
        if(a[i] <= a[j]){
            b[k++] = a[i++];
        }
        else{
            b[k++] = a[j++];
        }
    }
    //处理合并完后还有剩余的那个部分，因为该部分内部已经有序所以直接拷贝过来
    //因为合并的条件是两部分都未到达尾部，所以可能会有一个部分剩余数
    while( i < mid + 1){
        b[k++] = a[i++];
    }
    while( j < right + 1){
        b[k++] = a[j++];
    } 
    //将b[0..k-1] 复制到 a[left..right]
    //复制完a[left..right]有序
    int m = 0;
    int n = left;
    for( m = 0,n = left; m < k && n <= right; ++m,++n){
        a[n] = b[m];
    }
};

void MergeSort(int a[],int arrSize){
    int segSize = 1;
    // 有序子区间长度大于等于数组长度结束
    // 有序子区间长度按1 2 4 8……递增
    while( segSize < arrSize){
        int i = 0;
        while( i <= arrSize - 2*segSize){
            Merge(a,i, i + segSize-1,i + 2*segSize - 1);
            i = i + 2*segSize;
        }
	//剩余部分只有一个有序区间，不需处理
        //剩余部分还有两个有序区间，但是最后一个区间长度不够segSize，合并
        if(i + segSize < arrSize){
            Merge(a,i, i + segSize-1,arrSize - 1);
        }
        segSize += segSize;//有序区间长度加倍
    } 
};

int main()
{
    int x[] ={1,3,5,2,4,6,8,3};
    MergeSort(x,8);
    for (int i = 0; i < 8; ++i){
        cout<<x[i]<<"  ";
    } 

	while(true);
	return 0;
}