经典排序算法之归并排序|递归和迭代法代码均提供|c++代码实现|什么是归并排序|如何代码实现

MosesCD

已于 2024-03-24 21:13:29 修改

阅读量1k

点赞数 9

分类专栏：排序算法c++ 文章标签：算法排序算法数据结构

于 2024-03-09 10:16:54 首次发布

本文链接：https://blog.youkuaiyun.com/qq_64431512/article/details/136578113

版权

排序算法c++ 专栏收录该内容

11 篇文章

订阅专栏

引言

排序算法c++实现系列第5弹——归并排序

文章末尾还有本菜已实现的其他排序算法文章的链接。不过，排序算法这个系列还没更完，争取本周末搞完！之后还会有堆排序、桶排序等的代码实现，感兴趣的佳人可以点个赞&收藏，如果我有幸获得佳人们一个关注，感激涕零，呜呜呜呜呜呜呜呜...

算法介绍

归并排序（Merge Sort）是一种基于分治策略的排序算法，它将一个未排序的序列递归地划分成两个子序列，然后对这两个子序列分别进行排序，最后将排好序的子序列合并成一个有序的序列。归并排序的主要思想是将问题分解成更小的子问题，然后解决这些子问题，最后将这些解合并起来。归并排序是一种稳定的排序算法，适用于各种数据类型和数据分布情况。

本文中不仅给出了递归方法，也给出了迭代法实现归并排序。

归并排序的基本步骤如下：

分解：将待排序的序列分解成两个子序列，直到每个子序列只有一个元素为止。
排序：对每个子序列进行排序，可以使用递归来实现。
合并：将两个排好序的子序列合并成一个有序的序列。

算法详细步骤

下面是归并排序的详细算法描述：

递归分解：将待排序序列分成两个长度相等（或相差1，此时序列长度为奇数）的子序列，然后对每个子序列递归地应用归并排序，直到每个子序列的长度为1。（当子序列长度为1时，这个子序列就是有序的了）
合并操作：将两个排好序的子序列合并成一个有序的序列。合并操作的具体步骤如下：
- 创建一个临时数组用来存放合并后的结果。
- 设置两个指针，分别指向两个排好序的子序列的起始位置。
- 比较两个指针指向的元素，将较小或者较大（提供的代码中使用的是较小，如此排序后的序列是非降序的）的元素放入临时数组，并将该指针向后移动一位。
- 重复上述步骤，直到其中一个子序列的所有元素都已经放入临时数组。
- 将另一个子序列中剩余的元素依次放入临时数组。
复制操作：将临时数组中的排好序的元素复制回原始序列。千万不要忘了这一步！！

对于以上步骤，在代码中都有详细的注释，uu们如果有疑问欢迎评论区留言！

时间复杂度

归并排序的时间复杂度为O(nlogn)，其中 n 为待排序序列的长度。

代码实现

有关递归和迭代的实现，我的理解是递归一直从上往下执行，直到执行至单个元素，得到有序性，然后逐层自下向上返回，如此得到的全是有序数组；迭代是从单个元素开始，自下往上借助循环执行，也是在保证了有序性后再进行归并。

个人感觉递归版相对好理解一点，建议先把递归实现的思路和代码理解清晰，再去看迭代版。但其实迭代版只要考虑清楚low、high等变量的实现以及循环条件，其余的合并操作和递归版基本一致。

#include<bits/stdc++.h>
using namespace std;
template<typename T>
// 递归版
void merge_sort(T arr[], int low, int high) {
	if (low < high) {
		int mid = (low + high) / 2;
		// 对两个子序列进行排序，递归 
		merge_sort(arr, low, mid);
		merge_sort(arr, mid + 1, high);
		// 开始合并两个有序子序列 
		int i = low, j = mid + 1;  // 指向两个子序列开始的指针  
		T b[high - low + 1] = {0};  // 临时数组 
		int k = 0; // 记录临时数组下标 
		
		// 合并操作的具体步骤 
		while ((i <= mid) && (j <= high)) {
			if (arr[i] <= arr[j]) {
				b[k++] = arr[i++];
			} else {
				b[k++] = arr[j++];
			}
		}
		while (i <= mid) {
			b[k++] = arr[i++];
		}
		while (j <= high) {
			b[k++] = arr[j++];
		}
		
		// 赋值操作 
		for (int i = 0; i < k; i++) {
			arr[low + i] = b[i];
		}
	}

}
// 迭代版
template<typename T>
void Merge_sort(T arr[], int len) { // 个人习惯，虽然叫len，但其实是序列中最后一个数的下标，即n-1 
	for (int stride = 1; stride <= len; stride += stride) {
		for (int i = 0; i <= len; i += stride + stride) {
			// 迭代版的关键就在于low high mid的确定 
			int low = i, high = min(len, i + 2 * stride - 1);
//			int mid = (low + high) / 2;
			int mid = min(len, i + stride - 1);
			int p = low, q = mid + 1;
			T b[high - low + 1] = {0};
			int k = 0;
			while ((p <= mid) && (q <= high)) {
				if (arr[p] <= arr[q]) {
					b[k++] = arr[p++];
				} else {
					b[k++] = arr[q++];
				}
			}
			while (p <= mid) {
				b[k++] = arr[p++];
			}
			while (q <= high) {
				b[k++] = arr[q++];
			}
			for (int j = 0; j < k; j++) {
				arr[low + j] = b[j];
			}
		}
	}

}
int main() {
	int arr[] = {61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62};
	int len = (int) sizeof(arr) / sizeof(*arr);
//	merge_sort(arr, 0, len - 1);
	Merge_sort(arr, len - 1);
	for (int i = 0; i < len; i++) {
		cout << arr[i] << " ";
	}
	cout << endl;

	float arrf[] = {17.5, 19.1, 0.6, 1.9, 10.5, 12.4, 3.8, 19.7, 1.5, 25.4, 28.6, 4.4, 23.7, 5.4};
	int lenf = sizeof(arrf) / sizeof(*arrf);
//	merge_sort(arrf, 0, lenf - 1);
	Merge_sort(arrf, lenf - 1);
	for (int i = 0; i < lenf; i++) {
		cout << arrf[i] << " ";
	}
	return 0;
}

运行结果展示：