23--归并排序

 算法描述：就是将两个有序的合并为一个较大的有序的，直到完全有序为止，也称为2路归并。

其时间复杂度是，空间复杂度是，并且稳定。

代码如下：

#include<stdio.h>
#include<malloc.h>
#include<assert.h>

//一趟归并(自己使用，用static)，一趟归并的时间复杂度为O(n)
//gap:归并段的长度,因为l1,h1,l2,h2跟归并段的长度都有关系
static void Merge(int* arr, int len, int  gap)
{
	int low1 = 0;//第一个归并段的起始下标
	int high1 = low1 + gap - 1;//第一个归并段的结束下标
	int low2 = high1 + 1;//第二个归并段的起始下标
	int high2 = low2 + gap < len ? low2 + gap - 1 : len - 1;//第二个归并段的结束下标

	//总是比较l1和l2的值

	//准备工作
	//存放归并好的数据,动态申请空间
	int* brr = (int*)malloc(len * sizeof(int));
	//断言brr不为空
	assert(brr != NULL);

	int i = 0;//brr下标

	//有两个归并段,进行归并
	while (low2 < len)
	{
		//两个归并段都有数据，需要比较l1和l2,谁小谁下来
		while (low1 <= high1 && low2 <= high2)
		{
			if (arr[low1] <= arr[low2])
			{
				brr[i++] = arr[low1++];
			}
			else 
			{
				brr[i++] = arr[low2++];
			}
		}

		//一个归并段的数据已经完成了，另一个还有数据直接拉下来
		while (low1 <= high1)
		{
			brr[i++] = arr[low1++];
		}
		while (low2 <= high2)
		{
			brr[i++] = arr[low2++];
		}

		//下两个归并段
		low1 = high2 + 1;
		high1 = low1 + gap - 1;//high1可能越界，但一越界就从上面while循环出来了，况且下面也没有用high1进行判断
		low2 = high1 + 1;
		high2 = low2 + gap < len ? low2 + gap - 1 : len - 1;
		//high2 = low2 + gap - 1 < len - 1 ? low2 + gap - 1 : len - 1;
	}

	//从上面while循环出来即只有一个归并段
	//只有一个归并段,直接挪下来
	while (low1<len)
	{
		brr[i++] = arr[low1++];
	}

	//将归并好的数据拷贝到arr中
	for (i = 0; i < len; i++)
	{
		arr[i] = brr[i];
	}

	//释放内存
	free(brr);

}

//归并排序 O(nlog2n),O(n),稳定
void MergeSort(int* arr, int len)
{
	//log以2为底n的对数
	for (int i = 1; i < len; i*=2)
	{
		//一趟归并
		Merge(arr, len, i);
	}
}

void Show(int* arr, int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
}

int main()
{
	int arr[] = { 7,4,9,5,12,6,8,3,10,23,11 };
	int len = sizeof(arr) / sizeof(arr[0]);

	MergeSort(arr, len);
	Show(arr, len);

	return 0;
}