排序算法之归并排序

1）基本思想

归并排序的基本思想是将两个已经排好序的数组通过N-1次比较，归并到一个新的数组中，N是两个数组的元素个数之和。

比如数组：24 13 26 1 2 27 38 15，归并的方法是分别对数组的前四个数据和后四个数据排序，然后合并这两个部分排序的结果，而对前四个数据和后四个数据排序的方法也是通过将其分别分为两个小数组，然后合并的方法，即递归实现，这就是所谓的分而治之的思想。

2）算法实现

每一次合并两个已排序的数组时，需要一个新的包含两个数组总大小的空间来放置排序的结果，由于是递归实现，如果在每一次递归的过程中，都分配一段临时空间然后在该次排序结束时释放掉，那么这个分配和释放将占用很多时间。为了解决这个问题，可以在排序开始处分配一段与原始数组同等大小的空间用来放置各次递归的排序结果，然后在排序完全结束后释放掉这段空间。

代码如下：

#include "stdafx.h"
#include <iostream>
using namespace std;

void Merge(int* A, int* tempArray, int left, int center, int right)
{
    int start = left;
    int rleft = center + 1;
    int tleft = left;
    while(left <= center && rleft <= right)
    {
        if(A[left] <= A[rleft])
        {
            tempArray[tleft] = A[left++];
        }
        else
        {
            tempArray[tleft] = A[rleft++];
        }
        tleft++;
    }
    while(left <= center)
    {
        tempArray[tleft++] = A[left++];
    }
    while(rleft <= right)
    {
        tempArray[tleft++] = A[rleft++];
    }

    for(; start <= right; start++)
    {
        A[start] = tempArray[start];
    }
}

void Recursion(int* A, int* tempArray, int left, int right)
{
    if(left < right)
    {
        int center = (left + right)/2;
        Recursion(A, tempArray, left, center);
        Recursion(A, tempArray, center+1, right);
        Merge(A, tempArray, left, center, right);
    }
}

void print(int* A, int n)
{
    for(int i = 0; i < n; i++)
    {
        cout<<A[i]<<" ";
    }
    cout<<endl;
}

void mergeSort(int A[], int n)
{
    int* tempArray = new int[n];
    Recursion(A, tempArray, 0, n-1);
    delete [] tempArray;
}

int _tmain(int argc, _TCHAR* argv[])
{
    int A[8] = {24,13,26,1,2,27,38,15};
    print(A, 8);
    mergeSort(A, 8);
    print(A, 8);

    system("pause");
    return 0;
}

3）复杂度分析
归并排序使用的递归方法，最后一次的归并过程中最多需要N-1次比较，可以这样理解，每一次比较临时数组中都会多一个元素，由于共有N个元素，最后一个元素不需要比较，所以最多需要N-1次比较，假设N为2的幂，那么时间复杂度：

T(1) = 1;

T(n) = 2T(n/2) + n;

T(n)/n = T(n/2) /(n/2) + 1;

T(n/2) /(n/2) = T(n/4) /(n/4) + 1;

...

T(2)/2 = T(1)/1 + 1;

各式相加： T(n)/n = T(1)/1 + logn，最终，T(n) = O(nlogn).

归并排序很少用在主存排序中，其主要原因是归并排序需要附加与原始数组等大小的内存，同时还要来来回回将元素拷贝到临时数组中，并将其拷贝回来，因而增加了时空消耗。