devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

排序算法：归并排序（递归和非递归）_归并排序中间过程使用什么排序

作者：很楠不爱3 | 2024-04-20 02:03:08

赞

踩

归并排序中间过程使用什么排序

朋友们、伙计们，我们又见面了，本期来给大家解读一下有关排序算法的相关知识点，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！

C 语 言 专 栏：C语言：从入门到精通

数据结构专栏：数据结构

个  人  主  页 ：stackY、

​

目录

1.归并排序

1.1递归版本

代码演示：

1.2非递归版本 

代码演示：

测试排序：

改正代码1：

测试排序：

改正代码2：

1.3递归版本的优化

代码演示：

2.归并排序特性

1.归并排序

基本思想：
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤：

 

归并排序也分为递归和非递归版本，下面我们就来逐步学习： 

1.1递归版本

从上面的图中我们可以看出归并排序是分为两个阶段分解和合并，那么转化为代码的思想就是先划分小区间，然后将区间中最小的单独拿出来在另外的一个数组中进行尾插，等到最后一组数据排完之后，再将尾插排序完的整个数组再拷贝至原数组，这样子就完成了整个数组的排序。

那么通过这个过程可以发现：归并排序是需要单独开一个数组的，所以它的

空间复杂度是O（N），另外归并排序是先划分小区间再进行排序，那么就和二叉树中的后序遍历逻辑类似，先将整个数据一分为二，使得左区间和右区间有序，然后再将左右两个区间进行排序，那么整个数据就有序了，所以需要让左右区间再有序，也需要将做右区间各划分为两个区间，并且让它们的左右区间再有序，以此类推，直到区间内只剩一个数据就不需要再划分了，然后取两个区间小的值尾插到单独的一个数组，最后再次整体拷贝至原数组。

在递归时要注意几个问题：

1. 在递归的时候需要保存两个区间的起始和终止位置，以便访问。

2. 当一个区间已经尾插完毕，那么直接将另外一个区间的数据依次尾插。

3. 两个区间的数据都尾插完毕至tmp数组时，需要将tmp数组的数据再次拷贝至原数组。

4. 在拷贝到原数组时需要注意尾插的哪一个区间就拷贝哪一个区间。 

代码演示：

  1. void _MergerSort(int* a, int begin, int end, int* tmp)
  2. {
  3. 	//递归截止条件
  4. 	if (begin == end)
  5. 		return;
  6.  
  7. 	//划分区间
  8. 	int mid = (begin + end) / 2;
  9. 	//[begin,mid] [mid+1,end]
  10.  
  11. 	//递归左右区间
  12. 	_MergerSort(a, begin, mid, tmp);
  13. 	_MergerSort(a, mid + 1, end, tmp);
  14.  
  15. 	//将区间保存
  16. 	int begin1 = begin, end1 = mid;
  17. 	int begin2 = mid + 1, end2 = end;
  18. 	int i = begin;
  19.  
  20. 	//取两个区间小的值尾插
  21. 	//一个区间尾插完毕另一个区间直接尾插即可
  22. 	while (begin1 <= end1 && begin2 <= end2)
  23. 	{
  24. 		if (a[begin1] < a[begin2])
  25. 		{
  26. 			tmp[i++] = a[begin1++];
  27. 		}
  28. 		else
  29. 		{
  30. 			tmp[i++] = a[begin2++];
  31. 		}
  32. 	}
  33.  
  34. 	//再将剩余数据依次尾插
  35. 	//哪个区间还没有尾插就尾插哪一个
  36. 	while (begin1 <= end1)
  37. 	{
  38. 		tmp[i++] = a[begin1++];
  39. 	}
  40. 	while (begin2 <= end2)
  41. 	{
  42. 		tmp[i++] = a[begin2++];
  43. 	}
  44.  
  45. 	//再重新拷贝至原数组
  46. 	//尾插的哪个区间就将哪个区间拷贝
  47. 	memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
  48. }
  49.  
  50. //归并排序
  51. void MergerSort(int* a, int n)
  52. {
  53. 	//先创建一个数组
  54. 	int* tmp = (int*)malloc(sizeof(int) * n);
  55.  
  56. 	_MergerSort(a, 0, n - 1, tmp);
  57.  
  58. 	//释放
  59. 	free(tmp);
  60. }
归并排序的特性总结：
1. 归并的缺点在于需要 O(N) 的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
2. 时间复杂度： O(N*logN)
3. 空间复杂度： O(N)
4. 稳定性：稳定

1.2非递归版本 

由于递归代码在数据太多时可能会因为递归太深出现问题，所以我们也需要写出它们所对应的非递归版本的排序代码：非递归版本的归并排序直接可以使用循环来完成，但是坑点非常多，接下来我们就来慢慢排查。

我们可以先一个数据为一组，然后两两进行排序，然后将排序完的整体结果再重新拷贝至原数组，这样子就完成了一次排序，然后再将排序完的结果两个数据为一组，然后两两排序，然后将排序完的数据再拷贝至原数组，这样子就完成了第二次的排序，然后将数据四个分为一组，两两进行排序，再将排序完的数据拷贝至原数组，直到每组的数据超过或者等于数据的总长度即不需要在进行排序。

首先我们先创建一个开辟一个数组，然后设置一个gap用来分组，然后记录两个区间，对两个区间的数进行比较，小的尾插，再将剩余数据继续尾插，然后完成了一趟排序，再将排完序的数据再拷贝至原数组，再将gap * 2，继续完成剩余的排序，直到划分组的gap大于等于数据总长度即可完成全部的排序：

代码演示：

  1. //归并排序
  2. //非递归
  3. void MergerSortNonR(int* a, int n)
  4. {
  5. 	//创建数组
  6. 	int* tmp = (int*)malloc(sizeof(int) * n);
  7. 	if (tmp == NULL)
  8. 	{
  9. 		perror("tmp");
  10. 		exit(-1);
  11. 	}
  12. 	//划分组数
  13. 	int gap = 1;
  14.  
  15. 	while (gap < n)
  16. 	{
  17. 		int j = 0;
  18. 		for (int i = 0; i < n; i += 2 * gap)
  19. 		{
  20. 			//将区间保存
  21. 			int begin1 = i, end1 = i + gap - 1;
  22. 			int begin2 = i + gap, end2 = i + 2 * gap - 1;
  23.  
  24.  
  25. 			//取两个区间小的值尾插
  26. 			//一个区间尾插完毕另一个区间直接尾插即可
  27. 			while (begin1 <= end1 && begin2 <= end2)
  28. 			{
  29. 				if (a[begin1] < a[begin2])
  30. 				{
  31. 					tmp[j++] = a[begin1++];
  32. 				}
  33. 				else
  34. 				{
  35. 					tmp[j++] = a[begin2++];
  36. 				}
  37. 			}
  38.  
  39. 			//再将剩余数据依次尾插
  40. 			//哪个区间还没有尾插就尾插哪一个
  41. 			while (begin1 <= end1)
  42. 			{
  43. 				tmp[j++] = a[begin1++];
  44. 			}
  45. 			while (begin2 <= end2)
  46. 			{
  47. 				tmp[j++] = a[begin2++];
  48. 			}
  49. 		}
  50.  
  51. 		//将数据重新拷贝至原数组
  52. 		memcpy(a, tmp, sizeof(int) * n);
  53. 		//更新gap
  54. 		gap *= 2;
  55. 	}
  56.  
  57. 	//释放
  58. 	free(tmp);
  59. }
测试排序：
  1. void PrintArry(int* a, int n)
  2. {
  3. 	for (int i = 0; i < n; i++)
  4. 	{
  5. 		printf("%d ", a[i]);
  6. 	}
  7. 	printf("\n");
  8. }
  9.  
  10. void TestMergerSortNonR()
  11. {
  12. 	int a[] = { 10,6,7,1,3,9,4,2 };
  13. 	PrintArry(a, sizeof(a) / sizeof(int));
  14. 	MergerSortNonR(a, sizeof(a) / sizeof(int));
  15. 	PrintArry(a, sizeof(a) / sizeof(int));
  16. }
  17.  
  18.  
  19. int main()
  20. {
  21. 	TestMergerSortNonR();
  22. 	return 0;
  23. }

可以看到排序完成，而且还完成的不错，那么我们再来几组数据进行测试：

在这里我们使用的是8个数据，那如果我们使用9个或者10个数据呢？

  1. void PrintArry(int* a, int n)
  2. {
  3. 	for (int i = 0; i < n; i++)
  4. 	{
  5. 		printf("%d ", a[i]);
  6. 	}
  7. 	printf("\n");
  8. }
  9.  
  10. void TestMergerSortNonR()
  11. {
  12. 	int a[] = { 10,6,7,1,3,9,4,2,8,5 };
  13. 	PrintArry(a, sizeof(a) / sizeof(int));
  14. 	MergerSortNonR(a, sizeof(a) / sizeof(int));
  15. 	PrintArry(a, sizeof(a) / sizeof(int));
  16. }
  17.  
  18.  
  19. int main()
  20. {
  21. 	TestMergerSortNonR();
  22. 	return 0;
  23. }

可以看到数据发生错误，那么到底是为什么呢？我们可以来一起观察一下：

随着gap的2倍递增，那么会发生数据区间越界的问题，因为当数据是10个的时候，gap会递增到8，因此在访问数据的时候会发生越界，我们也可以观察一下这个越界的现象：

可以将数据访问的区间打印出来：

那么该怎么解决这个问题呢？

1. 首先不能排完一次序然后将数据整体拷贝，需要排完一组，拷贝一组。

2. 其次当发生越界中的第一、二种时可以直接break。

3. 当发生越界中的第三种时可以将边界进行修正。

改正代码1：

  1. //归并排序
  2. //非递归
  3. void MergerSortNonR(int* a, int n)
  4. {
  5. 	//创建数组
  6. 	int* tmp = (int*)malloc(sizeof(int) * n);
  7. 	if (tmp == NULL)
  8. 	{
  9. 		perror("tmp");
  10. 		exit(-1);
  11. 	}
  12. 	//划分组数
  13. 	int gap = 1;
  14.  
  15. 	while (gap < n)
  16. 	{
  17. 		int j = 0;
  18. 		for (int i = 0; i < n; i += 2 * gap)
  19. 		{
  20. 			//将区间保存
  21. 			int begin1 = i, end1 = i + gap - 1;
  22. 			int begin2 = i + gap, end2 = i + 2 * gap - 1;
  23. 			
  24. 			//end1和begin2越界直接跳出
  25. 			if (end1 >= n || begin2 >= n)
  26. 			{
  27. 				break;
  28. 			}
  29.  
  30. 			//end2越界可以进行修正
  31. 			if (end2 >= n)
  32. 			{
  33. 				end2 = n - 1;
  34. 			}
  35.  
  36. 			//取两个区间小的值尾插
  37. 			//一个区间尾插完毕另一个区间直接尾插即可
  38. 			while (begin1 <= end1 && begin2 <= end2)
  39. 			{
  40. 				if (a[begin1] < a[begin2])
  41. 				{
  42. 					tmp[j++] = a[begin1++];
  43. 				}
  44. 				else
  45. 				{
  46. 					tmp[j++] = a[begin2++];
  47. 				}
  48. 			}
  49.  
  50. 			//再将剩余数据依次尾插
  51. 			//哪个区间还没有尾插就尾插哪一个
  52. 			while (begin1 <= end1)
  53. 			{
  54. 				tmp[j++] = a[begin1++];
  55. 			}
  56. 			while (begin2 <= end2)
  57. 			{
  58. 				tmp[j++] = a[begin2++];
  59. 			}
  60.  
  61. 			//归并一组，拷贝一组
  62. 			memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
  63. 		}
  64. 		gap *= 2;
  65. 	}
  66.  
  67. 	//释放
  68. 	free(tmp);
  69. }
测试排序：
  1. void PrintArry(int* a, int n)
  2. {
  3. 	for (int i = 0; i < n; i++)
  4. 	{
  5. 		printf("%d ", a[i]);
  6. 	}
  7. 	printf("\n");
  8. }
  9.  
  10. void TestMergerSortNonR()
  11. {
  12. 	int a[] = { 10,6,7,1,3,9,4,2,8,5 };
  13. 	PrintArry(a, sizeof(a) / sizeof(int));
  14. 	MergerSortNonR(a, sizeof(a) / sizeof(int));
  15. 	PrintArry(a, sizeof(a) / sizeof(int));
  16. 	printf("\n");
  17.  
  18. 	int a2[] = { 10,6,7,1,3,9,4,2 };
  19. 	PrintArry(a2, sizeof(a2) / sizeof(int));
  20. 	MergerSortNonR(a2, sizeof(a2) / sizeof(int));
  21. 	PrintArry(a2, sizeof(a2) / sizeof(int));
  22. 	printf("\n");
  23.  
  24. 	int a3[] = { 10,6,7,1,3,9,4,2,8 };
  25. 	PrintArry(a3, sizeof(a3) / sizeof(int));
  26. 	MergerSortNonR(a3, sizeof(a3) / sizeof(int));
  27. 	PrintArry(a3, sizeof(a3) / sizeof(int));
  28. 	printf("\n");
  29.  
  30. }
  31.  
  32.  
  33. int main()
  34. {
  35. 	TestMergerSortNonR();
  36. 	return 0;
  37. }

改正过后就完全的解决了越界的问题，那么这种改进方法是归并一组，拷贝一组。

我们也可以将全部越界的区间进行修正，然后排序完一次将整个数据拷贝。

改正代码2：

将越界区间全部修正也是可以达到改进的目的，我们就以归并数据的逻辑为基础，然后修改区间，因此需要将越界的区间改为不存在的区间即可：

  1. //归并排序
  2. //非递归
  3. //改进代码2：
  4. void MergerSortNonR(int* a, int n)
  5. {
  6. 	//创建数组
  7. 	int* tmp = (int*)malloc(sizeof(int) * n);
  8. 	//划分组数
  9. 	int gap = 1;
  10.  
  11. 	while (gap < n)
  12. 	{
  13. 		int j = 0;
  14. 		for (int i = 0; i < n; i += 2 * gap)
  15. 		{
  16. 			//将区间保存
  17. 			int begin1 = i, end1 = i + gap - 1;
  18. 			int begin2 = i + gap, end2 = i + 2 * gap - 1;
  19.  
  20. 			//将越界的区间修改为不存在的区间
  21. 			if (end1 >= n)
  22. 			{
  23. 				end1 = n - 1;
  24.  
  25. 				//修改为不存在的区间
  26. 				begin2 = n;
  27. 				end2 = n - 1;
  28. 			}
  29. 			else if (begin2 >= n)
  30. 			{
  31. 				//不存在的区间
  32. 				begin2 = n;
  33. 				end2 = n - 1;
  34. 			}
  35. 			else if (end2 >= n)
  36. 			{
  37. 				end2 = n - 1;
  38. 			}
  39. 		
  40. 			//取两个区间小的值尾插
  41. 			//一个区间尾插完毕另一个区间直接尾插即可
  42. 			while (begin1 <= end1 && begin2 <= end2)
  43. 			{
  44. 				if (a[begin1] < a[begin2])
  45. 				{
  46. 					tmp[j++] = a[begin1++];
  47. 				}
  48. 				else
  49. 				{
  50. 					tmp[j++] = a[begin2++];
  51. 				}
  52. 			}
  53.  
  54. 			//再将剩余数据依次尾插
  55. 			//哪个区间还没有尾插就尾插哪一个
  56. 			while (begin1 <= end1)
  57. 			{
  58. 				tmp[j++] = a[begin1++];
  59. 			}
  60. 			while (begin2 <= end2)
  61. 			{
  62. 				tmp[j++] = a[begin2++];
  63. 			}
  64. 		}
  65.  
  66. 		//整体拷贝
  67. 		memcpy(a, tmp, sizeof(int) * n);
  68. 		gap *= 2;
  69. 	}
  70.  
  71. 	//释放
  72. 	free(tmp);
  73. }

 

1.3递归版本的优化

 当数据量非常多的时候使用递归版本可以进行一个优化，当递归到小区间的时候，我们可以采用插入排序来进行优化，这个优化只限于递归版本，在进行小区间中的插入排序时需要注意在前面的步骤递归到了哪个区间就使用插入排序排序哪个区间，所以在进行插入排序的时候需要注意排序的区间。

代码演示：

  1. void _MergerSort(int* a, int begin, int end, int* tmp)
  2. {
  3. 	//递归截止条件
  4. 	if (begin == end)
  5. 		return;
  6.  
  7. 	小区间优化
  8. 	//区间过小时直接使用插入排序，减少递归损耗
  9. 	if (end - begin + 1 < 10)
  10. 	{
  11. 		//         注意排序的区间
  12. 		InsertSort(a + begin, end - begin + 1); 
  13. 		return;
  14. 	}
  15.  
  16. 	//划分区间
  17. 	int mid = (begin + end) / 2;
  18. 	//[begin,mid] [mid+1,end]
  19.  
  20. 	//递归左右区间
  21. 	_MergerSort(a, begin, mid, tmp);
  22. 	_MergerSort(a, mid + 1, end, tmp);
  23.  
  24. 	//将区间保存
  25. 	int begin1 = begin, end1 = mid;
  26. 	int begin2 = mid + 1, end2 = end;
  27. 	int i = begin;
  28.  
  29. 	//取两个区间小的值尾插
  30. 	//一个区间尾插完毕另一个区间直接尾插即可
  31. 	while (begin1 <= end1 && begin2 <= end2)
  32. 	{
  33. 		if (a[begin1] < a[begin2])
  34. 		{
  35. 			tmp[i++] = a[begin1++];
  36. 		}
  37. 		else
  38. 		{
  39. 			tmp[i++] = a[begin2++];
  40. 		}
  41. 	}
  42.  
  43. 	//再将剩余数据依次尾插
  44. 	//哪个区间还没有尾插就尾插哪一个
  45. 	while (begin1 <= end1)
  46. 	{
  47. 		tmp[i++] = a[begin1++];
  48. 	}
  49. 	while (begin2 <= end2)
  50. 	{
  51. 		tmp[i++] = a[begin2++];
  52. 	}
  53.  
  54. 	//再重新拷贝至原数组
  55. 	//尾插的哪个区间就将哪个区间拷贝
  56. 	memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
  57. }
  58.  
  59. //归并排序
  60. void MergerSort(int* a, int n)
  61. {
  62. 	//先创建一个数组
  63. 	int* tmp = (int*)malloc(sizeof(int) * n);
  64.  
  65. 	_MergerSort(a, 0, n - 1, tmp);
  66.  
  67. 	//释放
  68. 	free(tmp);
  69. }

2.归并排序特性

1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(N)
4. 稳定性：稳定

朋友们、伙计们，美好的时光总是短暂的，我们本期的的分享就到此结束，最后看完别忘了留下你们弥足珍贵的三连喔，感谢大家的支持！ 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/454801
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号