排序算法之归并排序

归并排序是所有排序算法中最稳定的，其基本思想是：将待排序的元素分成大小大致相同的集合，分别对2个子集合进行排序，最终将排好的子集合合并为所以要求的排好序的集合。先看看c++的实现代码。

#include <iostream>
#include <string.h>
#include <malloc.h>
#include <assert.h>

using namespace std;

template < typename T >
class merge
{
    private:
        T *assist;    //辅助数组指针；
    public:
        ~merge()      //释放辅助空间
        {
            free( assist );
        }

        void mergeSort( T *a, int length )
        {
            int step = 1;

            assist = ( T* )malloc( sizeof( T ) * length ); //分配辅助数组内存空间
            assert( assist != NULL );

            while( step * 2 < length * 2 )             //合并终止条件，还可以让循环次数小于length/2
            {
                int leftBegin, leftEnd, rightBegin, rightEnd;   //合并段的起终位置
                int index = 0;

                for( leftBegin = 0; leftBegin < length;leftBegin = rightEnd )
                {
                    rightBegin = leftEnd = leftBegin + step;
                    rightEnd = rightBegin + step;

                    if( rightBegin > length - 1 )
                    {
                        rightBegin = leftEnd = length - 1;
                    }
                    if( rightEnd > length )
                    {
                        rightEnd = length;
                    }

                    //比较大小进行合并
                    while( leftBegin < leftEnd && rightBegin < rightEnd )
                    {
                        assist[ index++ ] = a[ leftBegin ] < a[ rightBegin ] ? a[ leftBegin++ ] : a[ rightBegin++ ];
                    }

                    //将剩余部分复制到辅助数组
                    while( leftBegin < leftEnd )
                    {
                        assist[ index++ ] = a[ leftBegin++ ];
                    }

                    while( rightBegin < rightEnd )
                    {
                        assist[ index++ ] = a[ rightBegin++ ];
                    }
                }

                //将辅助数组复制到原数组
                memcpy( a, assist, length * 4 );

                step *= 2;
            }
        }
};

int main()
{
    int *a;
    int length;

    cin >> length;
    a = ( int * )malloc( sizeof(int) * length );

    for( int i = 0; i < length; i++)
    {
        cin >> a[ i ];
    }

    merge<int> m;
    m.mergeSort( a, length );

    for( i = 0; i < length; i++)
    {
        cout << a[ i ] << " ";
    }
    cout << endl;

    return 0;
}

衡量一个算法的好坏，我们往往用时间复杂度进行衡量。当然还有与之类似的空间复杂度，在目前情况下，存储空间已经不是问题了，所以空间复杂度有所弱化。归并排序当n<=1时时间复杂度为O(1)，这个比较好理解，被排序的问题规模小于等于1时，问题在常数复杂度的情况下就可以完成。有点难度是当n>1时，T(n) = 2T(n/2) + O(n)。程序中有两个循环分别为：“while( step * 2 < length * 2 )”“for( leftBegin = 0; leftBegin < length;leftBegin = rightEnd )”，在最坏情况下他们最多循环n/2次，所以有2T(n/2)。在归并一趟结束后有一个内存拷贝memcpy，它要将临时空间中的所有数据复制到原来的数组中，用于下一趟归并。所以又有O(n)。常数级别我们一般不考虑，主要的是这个递归方程T(n)
= 2T(n/2) + O(n)，求解可得T(n) = O(nlogn)。

---

有不对的地方希望大家指正