归并排序——C语言描述，递归法与循环法

已于 2023-03-26 12:07:50 修改
阅读量84 收藏
点赞数
分类专栏： c语言学习 算法 文章标签： c语言 算法 排序算法
于 2023-03-22 21:28:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59469991/article/details/129719828
版权

归并排序——C语言描述，递归法与循环法

文章目录

0 测试用例框架

https://blog.csdn.net/m0_59469991/article/details/127137119?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22127137119%22%2C%22source%22%3A%22m0_59469991%22%7D

1 递归法

（1）算法思想

​ 2路归并：将n个元素的序列不断对半划分成子序列，然后再两两归并有序序列，如此反复，得到有序序列。占空间，效率高，稳定的排序

（2）时间复杂度：

​ 为nlogn。递归深度logn，最底下那层只有1元素，只扫描一次，最上面那层归并所有元素都得扫描一遍，类似等差数列，首项为1， 尾项为n，项数为|logn| + 1，所以时间复杂度为nlogn。

（3）空间复杂度：

​ 为n。最终需要n个元素的空间存相应的数据（不是nlogn，尽管每次合并操作都需要申请额外的内存空间，但在合并完成之后，临时开辟的内存空间就被释放掉了。在任意时刻，CPU 只会有一个函数在执行，也就只会有一个临时的内存空间在使用。临时内存空间最大也不会超过 n 个元素的大小，所以归并排序的空间复杂度是 O(n)）。

（4）稳定的排序：

​ 因为if (Arr02[Low] <= Arr02[j])的结果不过成功与否肯定会执行下面的语句，不会跳过。

（5）代码

/*MergeSort*/
void Merge(int *Arr01, int *Arr02, int Low, int Mid, int High) {
	int i, j, k;

	for (i = Low, j = Mid + 1; (Low <= Mid) && (j <= High); i++) {
		if (Arr02[Low] <= Arr02[j]) {
			Arr01[i] = Arr02[Low++];
		}
		else {
			Arr01[i] = Arr02[j++];
		}
	}

	if (Low <= Mid) {
		for (k = 0; k <= (Mid - Low); k++) {
			Arr01[i + k] = Arr02[Low + k];
		}
	}

	if (j <= High) {
		for (k = 0; k <= (High - j); k++) {
			Arr01[i + k] = Arr02[j + k];
		}
	}
}

void MSort(int *Arr01, int *Arr, int Low, int High) {
	int Mid;
	int Arr02[10];

	if (Low == High) {
		Arr01[Low] = Arr[Low];
	}
	else {
		Mid = (Low + High) / 2;
		MSort(Arr02, Arr, Low, Mid);
		MSort(Arr02, Arr, Mid + 1, High);
		Merge(Arr01, Arr02, Low, Mid, High);
	}
}

void MergeSort(int *Arr, int Num) {
	if ((Arr == NULL) || (Num <= 1)) {
		return;
	}

	MSort(Arr, Arr, 0, Num - 1);
}

（5）测试用例

void TestCmpArr(int *CmpArr, int Num, int *Arr) {
	int Index = 0;
	int CmpNum = 0;

	TestNum++;

	for (Index = 0; Index < Num; ++Index) {
		if (CmpArr[Index] == Arr[Index]) {
			CmpNum++;
		}
	}

	if (CmpNum != Num) {
		printf("Incorrect!\n");
		FaildNum++;
	}
	else {
		printf("Correct!\n");
		PassNum++;
	}
}

/*TestMergeSort*/
void TestMergeSort(void) {
	/*Test01: Normal*/
	int Arr01[] = { 1, 3, 2, 5, 4, 0 };
	int Num01 = 6;
	int CmpArr01[] = { 0, 1, 2, 3, 4, 5 };

	/*Test02: Exist same mem*/
	int Arr02[] = { 5, 3, 0, 3, 4};
	int Num02 = 5;
	int CmpArr02[] = { 0, 3, 3, 4, 5 };

	/*Test03: Normal*/
	int Arr03[] = { 7, 6, 5, 4, 3, 2, 1, 0 };
	int Num03 = 8;
	int CmpArr03[] = { 0, 1, 2, 3, 4, 5, 6, 7 };

	/*Test04: Two Mem*/
	int Arr04[] = { 1, 0 };
	int Num04 = 2;
	int CmpArr04[] = { 0, 1 };

	/*Test05: Only 1 Mem*/
	int Arr05[] = { 0 };
	int Num05 = 1;
	int CmpArr05[] = { 0 };

	printf("-------Test start----------\n");
	InitNum();

	/*Test01*/
	printf("\n-------Test 01----------\n");
	MergeSort(Arr01, Num01);
	PrintArr(Arr01, Num01);
	TestCmpArr(CmpArr01, Num01, Arr01);

	/*Test02*/
	printf("\n-------Test 02----------\n");
	MergeSort(Arr02, Num02);
	PrintArr(Arr02, Num02);
	TestCmpArr(CmpArr02, Num02, Arr02);

	/*Test03*/
	printf("\n-------Test 03----------\n");
	MergeSort(Arr03, Num03);
	PrintArr(Arr03, Num03);
	TestCmpArr(CmpArr03, Num03, Arr03);

	/*Test04*/
	printf("\n-------Test 04----------\n");
	MergeSort(Arr04, Num04);
	PrintArr(Arr04, Num04);
	TestCmpArr(CmpArr04, Num04, Arr04);

	/*Test05*/
	printf("\n-------Test 05----------\n");
	MergeSort(Arr05, Num05);
	PrintArr(Arr05, Num05);
	TestCmpArr(CmpArr05, Num05, Arr05);

	/*Test Result*/
	printf("\n-------Test result----------\n");
	TestResult();
}

打印结果：

-------Test start----------

-------Test 01----------

Arr[0] = 0

Arr[1] = 1

Arr[2] = 2

Arr[3] = 3

Arr[4] = 4

Arr[5] = 5

Correct!

-------Test 02----------

Arr[0] = 0

Arr[1] = 3

Arr[2] = 3

Arr[3] = 4

Arr[4] = 5

Correct!

-------Test 03----------

Arr[0] = 0

Arr[1] = 1

Arr[2] = 2

Arr[3] = 3

Arr[4] = 4

Arr[5] = 5

Arr[6] = 6

Arr[7] = 7

Correct!

-------Test 04----------

Arr[0] = 0

Arr[1] = 1

Correct!

-------Test 05----------

Arr[0] = 0

Correct!

-------Test result----------

Print test result;

TestNum = 5, PassNum = 5, FaildNum = 0

2 循环法

（1）算法思想

​ 直接将数组元素直接按一个元素为增量两两归并到一个临时数组，然后再以两个元素（上把的两倍）为增量将临时数组的元素归并回原数组。以此类推，反复执行前面的步骤，直至将原数组变得有序。

（2）时间复杂度

​ 为nlogn。外层循环每次以4的倍数递减，总共需log4(n) + 1次，中层循环次数为n/2k，内层循环归并时时需扫描数组元素的个数为2k次，所以中层加内层循环每次操作次数为n次。所以总时间复杂度为(log4(n) + 1)*n，比使用递归的归并排序时间复杂度（log2(n) + 1） * n要好。

例子：假如一共有8个元素(N = 8).循环次数如下表所示。

外层循环次数k中层循环次数内层循环数组移动次数
11N / 2k = 8/2 = 42k = 2
12N / 2k = 8/4 = 22k = 4
24N / 2k = 8/8 = 12k = 8
2

（3）空间复杂度

​ 只申请了一个大小为Sizeof(int) * Num 的空间，没有额外的栈空间.

（4）代码

/*MergeSort*/
void Merge02(int *Arr02, int *Arr01, int Low, int Mid, int High) {
	int i, j, k;

	for (i = Low, j = Mid + 1; (Low <= Mid) && (j <= High); i++) {
		if (Arr02[Low] <= Arr02[j]) {
			Arr01[i] = Arr02[Low++];
		}
		else {
			Arr01[i] = Arr02[j++];
		}
	}

	if (Low <= Mid) {
		for (k = 0; k <= Mid - Low; k++) {
			Arr01[i + k] = Arr02[Low + k];
		}
	}

	if (j <= High) {
		for (k = 0; k <= High - j; k++) {
			Arr01[i + k] = Arr02[j + k];
		}
	}
}

void MergePass(int *Arr02, int *Arr01, int Incre, int Num) {
	int i = 0;

	while ((i + 2 * Incre - 1) < Num) {
		Merge02(Arr02, Arr01, i, i + Incre - 1, i + 2 * Incre - 1);
		i += 2 * Incre;
	}

	if ((i + Incre - 1) < (Num - 1)) {
		Merge02(Arr02, Arr01, i, i + Incre - 1, Num - 1);
	} else {
		while (i < Num) {
			Arr01[i] = Arr02[i];
			i++;
		}
	}
}

/*MergeSorByCycle*/
void MergeSorByCycle(int *Arr, int Num) {
	int Incre = 1;
	int *Arr01 = NULL;

	if ((Arr == NULL) || (Num <= 1)) {
		return;
	}

	Arr01 = (int *)malloc(sizeof(int) * Num);
	if (Arr01 == NULL) {
		goto EXIT;
	}

	while (Incre < Num) {
		MergePass(Arr, Arr01, Incre, Num);
		Incre *= 2;
		MergePass(Arr01, Arr, Incre, Num);
		Incre *= 2;
	}	

EXIT:
	if (Arr01 != NULL) {
		free(Arr01);
		Arr01 = NULL;
	}
}

（5）测试用例

/*TestMergeSorByCycle*/
void TestMergeSorByCycle(void) {
	/*Test01: Normal*/
	int Arr01[] = { 1, 3, 2, 5, 4, 0 };
	int Num01 = 6;
	int CmpArr01[] = { 0, 1, 2, 3, 4, 5 };

	/*Test02: Exist same mem*/
	int Arr02[] = { 5, 3, 0, 3, 4 };
	int Num02 = 5;
	int CmpArr02[] = { 0, 3, 3, 4, 5 };

	/*Test03: Normal*/
	int Arr03[] = { 7, 6, 5, 4, 3, 2, 1, 0 };
	int Num03 = 8;
	int CmpArr03[] = { 0, 1, 2, 3, 4, 5, 6, 7 };

	/*Test04: Two Mem*/
	int Arr04[] = { 1, 0 };
	int Num04 = 2;
	int CmpArr04[] = { 0, 1 };

	/*Test05: Only 1 Mem*/
	int Arr05[] = { 0 };
	int Num05 = 1;
	int CmpArr05[] = { 0 };

	printf("-------Test start----------\n");
	InitNum();

	/*Test01*/
	printf("\n-------Test 01----------\n");
	MergeSorByCycle(Arr01, Num01);
	PrintArr(Arr01, Num01);
	TestCmpArr(CmpArr01, Num01, Arr01);

	/*Test02*/
	printf("\n-------Test 02----------\n");
	MergeSorByCycle(Arr02, Num02);
	PrintArr(Arr02, Num02);
	TestCmpArr(CmpArr02, Num02, Arr02);

	/*Test03*/
	printf("\n-------Test 03----------\n");
	MergeSorByCycle(Arr03, Num03);
	PrintArr(Arr03, Num03);
	TestCmpArr(CmpArr03, Num03, Arr03);

	/*Test04*/
	printf("\n-------Test 04----------\n");
	MergeSorByCycle(Arr04, Num04);
	PrintArr(Arr04, Num04);
	TestCmpArr(CmpArr04, Num04, Arr04);

	/*Test05*/
	printf("\n-------Test 05----------\n");
	MergeSorByCycle(Arr05, Num05);
	PrintArr(Arr05, Num05);
	TestCmpArr(CmpArr05, Num05, Arr05);

	/*Test Result*/
	printf("\n-------Test result----------\n");
	TestResult();
}

结果：

-------Test start----------

-------Test 01----------

Arr[0] = 0

Arr[1] = 1

Arr[2] = 2

Arr[3] = 3

Arr[4] = 4

Arr[5] = 5

Correct!

-------Test 02----------

Arr[0] = 0

Arr[1] = 3

Arr[2] = 3

Arr[3] = 4

Arr[4] = 5

Correct!

-------Test 03----------

Arr[0] = 0

Arr[1] = 1

Arr[2] = 2

Arr[3] = 3

Arr[4] = 4

Arr[5] = 5

Arr[6] = 6

Arr[7] = 7

Correct!

-------Test 04----------

Arr[0] = 0

Arr[1] = 1

Correct!

-------Test 05----------

Arr[0] = 0

Correct!

-------Test result----------

Print test result;

TestNum = 5, PassNum = 5, FaildNum = 0

Meditatorss
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常见排序算法之归并排序——归并排序
保护小周ღ的博客
07-12 1952
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法 （Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序 列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。...
最近对问题 分治法 ——C语言代码
05-23
3. **分治法实例：归并排序（Merge Sort）**： - **分解**：将一个大数组分为两个相等或接近相等的子数组。 - **解决**：对每个子数组进行递归排序。 - **合并**：将两个已排序的子数组合并为一个有序数组，比较...
归并排序（递归）——C语言实现
qq_41890240的博客
04-11 8981
文章目录一、归并排序定义二、图解归并过程三、动图展示四、分治递归五、归并排序代码 一、归并排序定义 归并排序：是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 二、图解归并过程 归并的思想就是，对于左右子区间都有序的序列，我们可以借助一个临时数组进行归并。定义两个指针begin1和begin2，分别
C语言实现归并排序（递归法）
2303_79296612的博客
11-12 1260
分解：将数组分割成两个数组，再分别将两个数组又细分成2个数组，直到，最后每个数组都是一个元素，这时将该单元素数组看为有序数组。此时我们再把这些小小小数组（数字）给合并，根据我们上面的艰苦奋斗，发现合并出来肯定有序，直到合并得就剩一个，那不就完成了吗！合并：将分割的有序数组进行排序，排成有序数组后继续为上一个分割它的数组合并，直到数组被合并成原来的数组，此时已经排好序了。上方我们合并的时候用的是有序数组来排，但是通常我们要的是给乱序数组排序。哎，那我就把小数组都再次分成两半，分成小小数组，再去归并排序；
c语言递归方法排序,归并排序，递归法，C语言实现。
weixin_42664597的博客
05-23 1201
利用归并排序法对序列排序的示意图(递归法)：一、算法分析：利用递归的分治方法：1、将原序列细分，直到成为单个元素；2、在将分割后的序列一层一层地按顺序合并，完成排序。细分通过不断深入递归完成，合并通过递归　　　一层层返回完成。二、C语言代码1、完成排序的三个函数void MergeSort(int l[],int lenght){int tmp[lenght];MSort(l,tmp,,lengh...
归并排序——动图+逐步讲解(C语言)
Brant_zero的博客
07-14 3233
归并排序（Merge-Sort）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。 将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有 序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 效果演示：先来看看流程图： 3.2 处理越界 修正边界法： 多步拷贝法：......
【归并排序】C语言实现归并排序
2302_79527141的博客
03-30 581
归并排序(MERGE–SORT)是建立在归并操作上的一种有效的排序算法该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。先进行一个一个数比较，在两个两个的比较…实录基本和上面的一样，越界处理不同。，把两组进行排序，接着排序进。比照函数，一步一步分析。递归函数是把数组分至为。
归并排序——分治（C语言）
Annabel_CM的博客
07-06 955
归并排序——分治 基本思想 假定排序表有n个元素，则可以看做n个有序表，每个子表长度为1，然后两两归并，依次重复，直到合并成一个长度为n的有序表为止。 基本步骤 1、确定分界点 mid = (l + r) / 2，将序列划分为两个序列 2、通过递归排序左右两段序列 3、归并——合二为一（方法：设置两个指针分别指向q[l] 和 q[mid + 1], 再找一个空数组，比较两指针所指的元素，将指针所指元素较小的元素复制到空数组中，指针向后移动，依次类推，最后将剩余的数组直接复制进入新的数组中） 基本模
MergeSort(迭代归并排序)——C语言实现
ctz6d1p的博客
08-17 1568
归并排序 mergesort c语言实现归并排序 迭代实现归并排序
【排序】归并排序详解（C语言）
m0_72637272的博客
06-01 438
将数组分割成两个数组，再分别将两个数组又细分成2个数组，直到，最后每个数组都是一个元素，这时将该单元素数组看为有序数组。将数组分割成两个数组，再分别将两个数组又细分成2个数组，直到，最后每个数组都是一个元素，这时将该单元素数组看为有序数组。：将分割的有序数组进行排序，排成有序数组后继续为上一个分割它的数组合并，直到数组被合并成原来的数组，此时已经排好序了。将分割的有序数组进行排序，排成有序数组后继续为上一个分割它的数组合并，直到数组被合并成原来的数组，此时已经排好序了。个元素，刚好是两个数组的长度，
C语言6钟排序法源码与解析
07-12
C语言6钟排序法源码与解析 在计算机科学中，排序算法是一个非常重要的概念，它们的原理和实现各有不同，但都是为了将一组数据按照一定的顺序排列。在C语言中，有多种排序算法，每种算法都有其优缺点，本文将对六种...
C语言 实现归并排序算法
09-01
在C语言中，归并排序通常通过循环或递归来实现。上述代码展示了一个使用循环的非递归实现。它首先分配临时空间来存储合并后的序列，然后通过一系列的迭代和指针操作，将序列逐步合并。另外，代码还提供了一个使用...
C语言排序法介绍.rar-综合文档
05-11
在"**C语言排序法介绍.docx**"文档中，你将会找到关于这些排序算法的详细解释、伪代码和可能的C语言实现示例，帮助你进一步理解和实践这些知识。通过学习和实践，你可以提升编程技能，为解决更复杂的计算问题打下...
递归函数 递归排序法
03-16
本篇将深入探讨递归函数的概念，递归排序法，以及如何在C语言中实现它们。 首先，我们要理解什么是递归函数。递归函数是指函数在执行过程中调用自身，每次调用都会产生一个新的子问题，直到子问题足够简单，可以...
C/C++ 多线程[1]---线程创建+线程释放+实例
Edwinwzy的博客
08-17 880
这篇博客写一下多线程的一个demo。多线程还是很有用的，C++程序员进阶的必通之路。大学里面学的那些小玩意儿，单线程就能搞定所有，真正的大型项目，还是会有很多多线程相关的。记住这个多线程demo的简单使用，那么后面进一步拓展就手到擒来了。
C/C++控制台贪吃蛇游戏的实现
最新发布
fzy20110826的博客
08-20 1088
本文对给定的贪吃蛇游戏代码进行详细分析。该游戏使用 C++语言编写，通过控制台界面实现了经典的贪吃蛇游戏玩法，包括登录、注册、游戏介绍、游戏操作和计分等功能。
C语言异常处理背后技术详解
极客代码
08-19 672
异常处理是一种编程语言机制，用于处理程序执行过程中出现的非预期情况。这些非预期情况可能是由外部输入错误、内存访问越界、除以零等引起的。异常处理机制允许程序在检测到这些非预期情况时，执行特定的处理流程，从而避免程序崩溃，提高程序的健壮性和可靠性。本文第一部分介绍了C语言异常处理的基础知识，包括异常处理的定义、C语言异常处理的常用方法（返回值、全局变量、栈展开）。通过这些方法，我们可以在C语言中实现基本的异常处理。然而，这些方法都有其局限性，不能完全满足复杂的异常处理需求。
C:数组传参的本质
JonlyMay的博客
08-17 1068
数组传参的本质
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值