C语言实现归并排序

思路：

创建一个动态空间(*p)作为排序辅助数组，其大小为(right - left + 1) * sizeof(int)。

归并排序每次递归的动作：

1. 将给定数组以中点为界，分为左右两部分，且左右两边的数字分别有序。（至于如何将它做到分别有序，则需使用分治实现）
2. 使用两个指针 L(初始值为左边界) 和 R(初始值为中点右侧的第一个数字 mid + 1) ，分别指向左右两边的左节点，比较指针指向的两个数字；
3. 如果左侧的数字小于等于右侧的数字，则将左侧的数字拷贝进入动态空间p，然后L++;
4. 如果左侧数字大于右侧数字，则将右侧数字拷贝进入动态空间p，然后R++;
5. 当左侧或者右侧数据拷贝完毕，即 !L <= mid 或者 !R <= right ，则停止比较。
6. 拷贝左侧或者右侧剩下的数字到p。
7. 将p的内容拷贝至原数组。

图解：

1. 分边和指针位置：

   

2. 第一次比较拷贝：arr[L] 不大于 arr[R]

   

3. 第二次: arr[L] 不大于 arr[R]； 第三次 arr[L] 大于 arr[R]；

   

4.  第四次：arr[L] 大于 arr[R]

   

5. 第五次：arr[L] 不大于 arr[R]

   

6. ……
7. 当左边或者右边遍历完成且全部拷贝，此时指针L越过了mid位到右侧数组，此时结束比较行为，将右侧数组中的剩余数字逐个拷贝进入p中，即指针R之后的数字。如下图所示：

   

8. 将p中的数组拷贝进入原数组arr。
9. 至此从left到right位置的数字就全部拷贝完毕了。

递归行为：

每次分别对左侧和右侧进行递归，当left == right结束该次递归。

以第一次深度递归为例：

 left == right时代表left和right指向同一个元素，单个元素必定有序，所以直接返回。

代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <malloc.h>
#include <windows.h>
#include <memory.h>
//归并排序：
/*
arr:指定数组
left:判定左边界
right:判断右边界
mid:判断中点
*/
void Merge(int* arr, int left, int right, int mid)
{
	int *p = (int*)malloc((right - left + 1) * sizeof(int));
	int *temp = p;
	memset(p, 0, (right - left + 1) * sizeof(int));
	int L = left;
	int R = mid + 1;
	while (L <= mid && R <= right)
	{
		*p++ = arr[L] < arr[R] ? arr[L++] : arr[R++];
	}
	while (L <= mid)
	{
		*p++ = arr[L++];
	}
	while (R <= right)
	{
		*p++ = arr[R++];
	}

	memcpy(arr + left, temp, (right - left + 1) * sizeof(int));

	free(temp);
	temp = NULL;
}

void MergeSort(int* arr, int left, int right)
{
	if (left == right)
		return;
	int mid = left + ((right - left)>>1);

	MergeSort(arr, left, mid);			//左半边
	MergeSort(arr, mid + 1, right);		//右半边
	Merge(arr, left, right, mid);		//排序
}

int main()
{
	int arr[10] = { 9,8,3,5,2,1,6,4,7,10};
	MergeSort(arr, 0, sizeof(arr)/ sizeof(arr[0]) - 1);

	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}

	system("pause");
	return 0;
}