教你如何一步一步写出归并排序，算法详解(C语言)

1.首先写出算法的核心：将两个有序数组合并为一个新数组的算法

int Merge_1(int arr[], int len) {
	int* b = (int*)malloc(len * sizeof(int));//开辟辅助数组空间
	int k = 0;//给辅助数组下标一个初始值，让程序不报错
	int start1, start2, end1, end2;//暂定start为头end为尾，此时end是能取到的所以下面是小于等于，之后发现可以优化
	//算法核心：将两个数组按从小到大合并为一个新数组
	while (start1 <= end1 && start2 <= end2) {
		b[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
	}
	while (start1 <= end1) {
		b[k++] = arr[start1++];
	}
	while (start2 <= end2) {
		b[k++] = arr[start2++];
	}
}

2.设置小步长和大步长（两个for循环），小步长控制两个要合并数组的跳跃，大步长控制从一组要合并的数组跳到另一组要合并的数组，并在最后交换辅助数组，以继续进行归并排序(seg===step我后面用的seg)，特别说明一下因为需要被合并的两个数组必须是有序的所以步长必须从1开始到len-1结束否则结果不是无序就是不完全有序

int Merge_2(int arr[], int len) {
	int* b = (int*)malloc(len * sizeof(int));
	int k = 0;
	int start1, start2, end1, end2;
	//seg(小步长)配合start(两个start间是大步长)，seg作用是给start赋值，start起(循环次数)的决定作用
	for (int step = 1; step < len; step *= 2) {//1,2,4,8,
		for (int start = 0; start < len; start += step)//0-1,2-3,4-5,6-7//0-3,4-7//0-7
		{
			/*while (start1 <= end1 && start2 <= end2) {
				b[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
			}
			while (start1 <= end1) {
				b[k++] = arr[start1++];
			}
			while (start2 <= end2) {
				b[k++] = arr[start2++];
			}*/
		}
		//交换数组
		int* temp = arr;
		arr = b;
		b = temp;
	}
}

3.开始设置k，start12，end12的变量值，设置后会发现代码可以优化，下方代码优化前和优化后

int Merge_3(int arr[], int len) {
	int* b = (int*)malloc(len * sizeof(int));
	for (int step = 1; step < len; step *= 2) {
		for (int start = 0; start < len; start += step*2)
		{
			int k = start;
			int start1 = start;
			int start2 = get_min(start + step,len);
			int end1 = get_min(start + step - 1,len);
			int end2 = get_min(start + step - 1 + step,len);
			while (start1 <= end1 && start2 <= end2) {
				b[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
			}
			while (start1 <= end1) {
				b[k++] = arr[start1++];
			}
			while (start2 <= end2) {
				b[k++] = arr[start2++];
			}
		}
	}
	//交换数组
	int* temp = arr;
	arr = b;
	b = temp;

}

上方代码可以看出-1和=可以相互抵消，于是优化后的代码如下

int Merge_3(int arr[], int len) {
	int* b = (int*)malloc(len * sizeof(int));
	int k, start1, start2, end1, end2;
	for (int seg = 1; seg < len; seg *= 2) {
		for (int start = 0; start < len; start += seg * 2) {

			k = start;
			start1 = start;
			end1 = start2 = get_min(start + seg, len);//start、start1和start2必须是能取到的位置
			end2 = get_min(start + seg * 2, len);//end1和end2必须是取不到的位置
			while (start1 < end1 && start2 < end2)
				b[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
			while (start1 < end1)
				b[k++] = arr[start1++];
			while (start2 < end2)
				b[k++] = arr[start2++];
		}
		//指针互换，轮流充当辅助数组
		int* temp = arr;
		arr = b;
		b = temp;
	}

}

4.至此代码核心已经全部写完，但此时发现又出现了一个小问题，那就是有可能改变了arr指针的指向空间，改变了空间后原定的最大空间大小就不能用了（可能会影响后续代码的执行）所以我们不想改变空间指向，有两种解决办法，一是弄一个计数器，奇数和偶数的结果是固定的，以此判断空间指向是否改变如果改变就再次重新赋值换回来，二是弄一个临时的数组指针a让它等于arr最后判断a是否指向arr，以此判断此时哪个指针所指向的是真实数组，最后别忘记释放开辟的空间，我采用的是第二种方法，也是官方使用的写法，全代码如下

int Merge_s(int arr[], int len) {
	int* a = arr;
	int* b = (int*)malloc(len * sizeof(int));
	int k,start1,start2,end1,end2;
	for (int seg = 1; seg < len; seg *=2) {
		for (int start = 0; start < len; start += seg*2) {
			
			k = start;
			start1 = start;
			end1 = start2 = get_min(start + seg, len);//start、start1和start2必须是能取到的位置
			end2 = get_min(start + seg * 2, len);//end1和end2必须是取不到的位置
			while (start1 < end1 && start2 < end2)
				b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
			while (start1 < end1)
				b[k++] = a[start1++];
			while (start2 < end2)
				b[k++] = a[start2++];
		}
		//指针互换，轮流充当辅助数组
		int* temp = a;
		a = b;
		b = temp;
	}
	//出循环后a一定是排好的数组，但是由于ab互换的次数不知所以要判断一下此时的a是不是指向真数组，如果不是要给真数组重新赋值
	if (a != arr) {//a指针不指向原数组，说明a指向临时数组，b是真数组
		for (int i = 0; i < len; i++)
			b[i] = a[i];//给真数组赋值
		free(a);//释放临时数组的空间
	}
	else {
		free(b);
	}
	return 1;
}

有问题和错误欢迎留言，让我们共同进步！