归并排序（递归代码与非递归代码以及细节）

将大的问题分解为小的问题，以解决小问题完善大的问题，合并小为大；分治思想

有递归与非递归的算法、

递归算法

代码完成（递归）

void _MergeSort(int* a, int left, int right, int* tmp)
{
    int mid = left + (right - left) / 2;
    if (left >= right)
    {
        return;
    }
    //先进入递归，后进行后续排序；
    _MergeSort(a, left, mid, tmp);
    _MergeSort(a, mid+1,right, tmp);
    //合并两个有序的数组
    int begin1 = left, end1 = mid;
    int begin2 = mid + 1, end2 = right;
    int i = left;
    //小的先赋值再tmp数组中
    while (begin1 <= end1     && begin2 <= end2)
    {
        if (a[begin1] < a[begin2])
        {
            tmp[i++] = a[begin1++];
        }
        else
        {
            tmp[i++] = a[begin2++];
        }
    }
    //将2个数组中没遍历完全的数组，剩余部分赋值再tmp数组中
    while (begin1 <= end1)
    {
        tmp[i++] = a[begin1++];
    }
    while (begin2 <= end2)
    {
        tmp[i++] = a[begin2++];
    }
    //合并两个有序的数组

    //将有序的大数组拷贝到原数组中
    //这里必须要提前拷贝，因为上一层需要原数组的子数组有序才可排序
    for (int j = left; j <= right; j++)
    {
        a[j] = tmp[j];
    }
}

void MergeSort(int* a, int n)
{
    int* tmp = (int*)malloc(sizeof(int) * n);
    if (!tmp)
    {
        perror("malloc fail\n");
        exit(-1);
    }
    _MergeSort(a, 0, n - 1, tmp);
    free(tmp);
    tmp = NULL;
}

递归展开图（int arr[] = { 7,5,6,3,9,8,2,1,4,5 };）

类似二叉树后序遍历的思想，先将最左子树有序，然后再上一根的右子树有序，合并后到上一层.

画图理解

将数组分为左半和右半边

再将左半边分为下一个左半边和右半边

再将8和5分开

到了最后区间只有一个元素的时候返回，做上一层所需要的归并有序左（右）区间等待归并

左右区间开始归并，排序完毕后返回上一层，做上一层的有序半区间等等归并

上一层的右区间不为一个结点，开始分为左右区间

该区间只有一个元素的时候返回，做上一层所需要的归并有序左（右）区间等待归并

进入右区间，右区间分为左右区间

到了最后区间只有一个元素的时候返回，做上一层所需要的归并有序左（右）区间等待归并

左右区间开始归并，排序完毕后返回上一层，做上一层的有序半区间等等归并

左右区间开始归并，排序完毕后返回上一层，做上一层的有序半区间等等归并

返回

开始归并该层数据，排序完毕后返回上一层，做上一层的有序半区间等等归并

.........

.........

省略右大半边过程，的到右边有序区间数据

最后合并左右大区间有序数据

合并完毕返回函数

非递归算法

从最小归并多组——>最大归并单组

画图理解

首先完成最小组的归并

归并后

小组与小组归并（要注意控制边界问题否则会出大事！！），这里的最后一小组，无法归并，所以我们先归并前4小组数据，

归并后

最后的左大组的归并，为最后归并做准备

归并后

最后，归并，对右边合并组做边界调整

            if (end1 >= n||begin2>=n)
            {
                break;
            }
            if (end2>=n)
            {
                end2 = n - 1;
            }

end1与begin2存在，但是end2得距离越界，调整后end2为n-1；

最后归并得

最后结束程序返回有序得数组。

注意非递归得边界问题十分重要一定一定要注意，控制好！

代码完成（非递归）

//归并的非递归排法
void MergeSortNonR(int* a, int n)
{
    int* tmp = (int*)malloc(sizeof(int) * n);
    if (!tmp)
    {
        perror("malloc fail\n");
        exit(-1);
    }
    int gap = 1;
    while (gap <= n)
    {
        //每一次归并都是一整层归并
        //所有的数开始一个与一个开始归并，然后再两个和两个归并，然后三个三....
        //....最后左大半边（N/2）与右大半边（N/2）开始归并并结束
        for (int i = 0; i < n; i += 2 * gap)//gap是每组的个数，2*gap就是到下一组归并组
        {
            //[i,I+GAP-1]与[i+gap,i+2*gap-1]
            int begin1 = i, end1 = i + gap - 1;
            int begin2 = i+gap, end2 = i + 2*gap - 1;
            int index = i;
            if (end1 >= n||begin2>=n)
            {
                break;
            }
            if (end2>=n)
            {
                end2 = n - 1;
            }
            while (begin1 <= end1 && begin2 <= end2)
            {
                if (a[begin1] < a[begin2])
                {
                    tmp[index++] = a[begin1++];
                }
                else
                {
                    tmp[index++] = a[begin2++];
                }
            }
            while (begin1 <= end1)
            {
                tmp[index++] = a[begin1++];
            }
            while (begin2 <= end2)
            {
                tmp[index++] = a[begin2++];
            }
            //每2小组归并后返回a数组，为下一次做准备
            for (int j = i; j <= end2; j++)
            {
                a[j] = tmp[j];
            }
        }
        //一次gap后一起赋值给a
        /*for (int j = 0; j 

---