合并两个排序的整数数组A和B变成一个新的数组（归并排序）

归并排序：将问题分成一些小的问题然后递归求解，将分的阶段得到的各答案合并在一起。
将两个有序数组合并为一个，给出A=[1,2,3,4]，B=[2,4,5,6]，返回 [1,2,2,3,4,4,5,6]。
解题思路：从头开始比较两个数列中的数，哪一个小就取出依次存入新的数组中，直到其中一个全部比较完，将另一个数组剩下的部分直接存入新的数组中。

vector<int> mergeSortedArray(vector<int> &A, vector<int> &B) {
        int i=0,j=0;
        std::vector<int>c;      
        while(i<A.size()&&j<B.size()){
            if(A[i]<B[j])
                c.push_back(A[i++]);
            else
                c.push_back(B[j++]);
        }
        while(i<A.size()){
            c.push_back(A[i++]);
        }
        while(j<B.size()){
            c.push_back(B[j++]);
        }
        return c;
    }

将一个乱序数组排序
归并排序：将问题分成一些小的问题然后递归求解，将分的阶段得到的各答案合并在一起。
将乱序数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。
将A,B排序，当分出来的小组只有一个数据时（数据长度为1，即数据起始下标等于终止下标），可以认为这个小组组内已经达到了有序。

#include <iostream>
using namespace std;

void mergearray(int a[], int first, int mid, int last, int temp[])
{
   int i = first, j = mid + 1;
   int m = mid,   n = last;
   int k = 0;

   while (i <= m && j <= n)
   {
       if (a[i] <= a[j])
           temp[k++] = a[i++];
       else
           temp[k++] = a[j++];
   }

   while (i <= m)
       temp[k++] = a[i++];

   while (j <= n)
       temp[k++] = a[j++];

   for (i = 0; i < k; i++)
       a[first + i] = temp[i];//对first-last排序
}
void mergesort(int a[], int first, int last, int temp[])
{
   if (first < last)
   {
       cout<<"sort"<<"   "<<first<<"   "<<last<<endl;
       int mid = (first + last) / 2;
       cout<<"left"<<"   "<<first<<"   "<<mid<<endl;
       mergesort(a, first, mid, temp);    //左边有序
       cout<<"right"<<"   "<<mid+1<<"   "<<last<<endl;
       mergesort(a, mid + 1, last, temp); //右边有序
       cout<<"merge   "<<first<<"   "<<last<<endl;
       mergearray(a, first, mid, last, temp); //再将二个有序数列合并
   }
}




int main()
{
    int a[]={10,50,30,40,20};
    int length=sizeof(a)/sizeof(a[0]);
    int temp[length];
    mergesort(a,0,length-1,temp);
    for(int i=0;i<length;i++)
        cout<<a[i]<<endl;
    return 0;
}

输出结果:
sort 0 4
left 0 2

sort 0 2
left 0 1

sort 0 1
left 0 0
right 1 1
merge 0 1
right 2 2
merge 0 2
right 3 4

sort 3 4
left 3 3
right 4 4
merge 3 4
merge 0 4
10
20
30
40
50

第一次进入mergesort函数
左边first——mid是0-2（超过一个元素）继续划分左边

再一次进mergesort函数（0-2）
左边first——mid是0-1（超过一个元素）继续划分

再一次进入mergesort函数（0-1）
左边fisrt——mid是0-0（一个元素）mid+1-last是1-1（一个元素），因此合并排序左边和右边两个数组（两个元素）0和1

退出到上一次递归循环执行到的语句，继续执行后续语句
右边排序mid+1——last是2-2（只有一个元素），因此合并排序左边有序数组0-1和右边数组2

退出到上一次递归执行到的语句，继续执行后续语句
右边排序mid+1——last是3-4，（超过一个元素）继续划分

进入mergesort函数（3-4）
左边first——mid是3-3，右边是mid+1——last是4-4，都仅有一个元素，因此合并排序

退出到上一次递归未执行语句处，继续执行
合并左边有序数组0,1,2和右边有序数组3,4
归并排序结束！

算法复杂度：

时间复杂度：
平均时间复杂度：O（nlogn）
最好情况复杂度：O（nlogn）
最坏时间复杂度：O ( nlogn )
平均、最好、最坏时间复杂度都相同，因此稳定性非常好！
空间复杂度： O(n)