排序算法之归并排序

问题定义

问题输入：n个数的一个序列<$a_1$,$a_2$,……，$a_n$>
问题输出：输入序列的一个排列<$a_1'$,$a_2'$,……，$a_3'$>

问题分析

归并排序算法完全遵循分治模式。直观上其操作如下：
分解：分解待排序的n个元素的序列成各具n/2个元素的两个子序列。
解决：使用归并排序递归地排序两个子序列。
合并：合并两个已排序的子序列以产生已排序的答案。
假定存在数据A，p 是其数组的起始位置，r是数组的终止位置。Merge_Sort(A,p,r)排序子数组A[p..r]中的元素。若p>=r，则该子数组最多有一个元素，所以已经排好序。否则，分解步骤简单地计算一个下标q，将数组A[p..r]分成两个子数组A[p..q]和A[q+1..r]，前者包含n/2个元素，后者包含n/2个元素。故可形成如下的伪代码：

Merge_Sort(A,p,r)
{
    if(p<r)
    {
        q=(p+r)/2;
        Merge_Sort(A,p,q);   //递归左侧
        Merge_Sort(A,q+1,r);  //递归右侧
        Merge(A,p,q,r);   //合并左右两侧的排序结果
    }
}

Merge(A,p,q,r)    //从小到大
{
    while(左右两侧同时比较)
    {
        if(左侧<右侧)
        {
            左侧赋值给新数组；
        }
        else 
        {
            右侧赋值给新数组；
        }
    左侧剩余数据全部放进新数组；
    右侧剩余数据全部放进新数组；

}

代码

void Merge_Sort(vector<int>& vec,int first,int last,int *q)
{
    if (first < last)
    {
        int mid = (first + last) / 2;
        Merge_Sort(vec,0,mid,q);
        Merge_Sort(vec,mid+1,last, q);
        Merge(vec, first, last, mid, q);
    }
}

void Merge(vector<int>& vec, int first, int last,int mid, int *q)
{ 
    int i = first;
    int j = mid + 1;
    int m = mid;
    int n = last;
    int k = 0;
    while (i<=m &&j<=n)
    {
        if (vec[i] < vec[j])
        {
            q[k++] = vec[i++];
        }
        else
        {
            q[k++] = vec[j++];
        }
    }
    while (i <= m)
    {
        q[k++] = vec[i++];
    }

    while (j <= n)
    {
        q[k++] = vec[j++];
    }
    for (i = 0; i < k; i++)
    {
        vec[first + i] = q[i];
    }
}

测试函数

void show(vector<int> vec)
{
    vector<int>::iterator it = vec.begin();
    for (; it != vec.end(); it++)
    {

        cout << *it << " ";
    }
    cout << endl;
}
int main()
{
    vector<int> vec;
    for (int i =5; i >=0; i--)
    {
        vec.push_back(i);
    }
    show(vec);
    int n = vec.size();
    int *p = new int[n];
    if (p == NULL)
    {
        return false;
    }
    Merge_Sort(vec,0,(n-1),p);   //归并排序
    show(vec);
    return 0;
}

时间复杂度分析

针对该问题，我们构造一棵树，原始规模为n 的树被分割成规模为n/2的树……直至把原始规模为n的树分割成规模为1的树，此时树的高度为lgn，因此此时时间复杂度为O(nlogn).后期将证明。