目录
引言
在学习完 数据结构——快速排序 后，我们接着学习一种高效的排序方法——归并排序
求点赞收藏关注！！！
归并排序
1.算法思想
归并排序的算法思想主要基于分而治之（Divide and Conquer）的策略。这个策略涉及将原始问题分解成较小的、相似的子问题，递归地解决这些子问题，然后将解决方案合并起来以解决原始问题。在归并排序中，这个策略被应用于数组的排序上。
2.算法步骤
创建临时数组：这一步是确保在归并过程中有足够的空间来暂存排序后的数据，以避免在原数组上进行修改时破坏未排序的数据。
分解：归并排序的核心在于递归地将数组分解为更小的部分，直到每个部分只包含一个元素或为空。这是通过计算中点 mid 并将数组分为左右两部分来实现的。
递归调用：对于每个分解得到的子数组段，递归地调用归并排序函数，直到达到基本情况（即子数组段只有一个元素或为空）。这个过程确保了所有子数组段最终都会变得有序。
归并：当两个相邻的子数组段都已经被排序后，使用两个指针begin1和begin2分别遍历这两个子数组，并将较小的元素依次放入临时数组 tmp 中。这个过程会持续到两个子数组都被完全遍历。
拷贝回原数组：归并完成后，使用memecpy函数或循环将临时数组 tmp 中的有序数据拷贝回原数组 arr 的对应位置。这一步确保了原数组在递归调用结束后会被更新为有序状态。
递归完成：随着递归调用的逐层返回，每个子数组段的有序性逐渐扩展到整个数组。当最顶层的递归调用返回时，整个数组 arr 就完成了排序。
看个图可能容易理解一点，像这样：
动图演示：
3.代码实现
void _MergeSort(int* arr, int* tmp, int begin, int end)
{
// 如果当前数组段只有一个元素或没有元素，则无需排序，直接返回
if (begin >= end)
{
return;
}
// 计算中间索引，将数组段分为两半
int mid = (begin + end) / 2;
// 递归地对左半部分进行排序
_MergeSort(arr, tmp, begin, mid);
// 递归地对右半部分进行排序
_MergeSort(arr, tmp, mid + 1, end);
// 归并两个已排序的数组段
// 设置左右两个子数组的起始和结束索引
int begin1 = begin;
int end1 = mid;
int begin2 = mid + 1;
int end2 = end;
int index = begin; // tmp 数组的当前写入位置
// 当两个子数组都有元素时，比较并归并
while (begin1 <= end1 && begin2 <= end2)
{
if (arr[begin1] < arr[begin2])
{
tmp[index++] = arr[begin1++];
}
else
{
tmp[index++] = arr[begin2++];
}
}
// 如果左子数组还有剩余元素，直接复制到 tmp
while (begin1 <= end1)
{
tmp[index++] = arr[begin1++];
}
// 如果右子数组还有剩余元素，直接复制到 tmp
while (begin2 <= end2)
{
tmp[index++] = arr[begin2++];
}
// 将排序后的数据从 tmp 复制回 arr
memcpy(arr + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}
// MergeSort 函数的目的是对数组 arr 进行归并排序，n 是数组的长度
void MergeSort(int* arr, int n)
{
// 分配一个临时数组用于归并过程中的数据交换
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail:");
return;
}
// 调用递归的归并排序函数，对数组进行排序
_MergeSort(arr, tmp, 0, n - 1);
free(tmp);
tmp = NULL;
}4.复杂度分析
时间复杂度：通常情况下，需要递归logN层，每层都需要遍历，因此时间复杂度为O(N logN)。
空间复杂度：通常情况下，需要创建tmp临时数组，因此空间复杂度为O(N)。
5.算法优化
(1)区间优化
当递归调用层数越多时，最后三层的递归调用会浪费大量时间。为了避免这种情况，我们就可以采用小区间使用插入排序的方法。这与我们之前学习快排的情况类似。
代码如下：
void InsertSort(int* arr, int n)
{
for (int i = 0; i < n - 1; i++)
{
int end = i;
int tmp = arr[end + 1];
while (end >= 0)
{
if (tmp < arr[end])
{
arr[end + 1] = arr[end];
--end;
}
else
{
break;
}
}
arr[end + 1] = tmp;
}
}
void _MergeSort(int* arr, int* tmp, int begin, int end)
{
// 如果当前数组段只有一个元素或没有元素，则无需排序，直接返回
if (begin >= end)
{
return;
}
// 小区间优化
if (end - begin + 1 < 10)
{
InsertSort(arr + begin, end - begin + 1);
}
// 计算中间索引，将数组段分为两半
int mid = (begin + end) / 2;
// 递归地对左半部分进行排序
_MergeSort(arr, tmp, begin, mid);
// 递归地对右半部分进行排序
_MergeSort(arr, tmp, mid + 1, end);
int begin1 = begin;
int end1 = mid;
int begin2 = mid + 1;
int end2 = end;
int index = begin;
while (begin1 <= end1 && begin2 <= end2)
{
if (arr[begin1] < arr[begin2])
{
tmp[index++] = arr[begin1++];
}
else
{
tmp[index++] = arr[begin2++];
}
}
while (begin1 <= end1)
{
tmp[index++] = arr[begin1++];
}
while (begin2 <= end2)
{
tmp[index++] = arr[begin2++];
}
memcpy(arr + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}
(2)判断区间是否有序
在归并排序合并时，如果两个区间已经有序，即 arr[end1] <= arr[begin2] 时就不需要对其进行归并。
代码如下：
void _MergeSort(int* arr, int* tmp, int begin, int end)
{
// 如果当前数组段只有一个元素或没有元素，则无需排序，直接返回
if (begin >= end)
{
return;
}
// 小区间优化
if (end - begin + 1 < 10)
{
InsertSort(arr + begin, end - begin + 1);
}
// 计算中间索引，将数组段分为两半
int mid = (begin + end) / 2;
// 递归地对左半部分进行排序
_MergeSort(arr, tmp, begin, mid);
// 递归地对右半部分进行排序
_MergeSort(arr, tmp, mid + 1, end);
int begin1 = begin;
int end1 = mid;
int begin2 = mid + 1;
int end2 = end;
int index = begin;
if (arr[begin2] < arr[end1])
{
while (begin1 <= end1 && begin2 <= end2)
{
if (arr[begin1] < arr[begin2])
{
tmp[index++] = arr[begin1++];
}
else
{
tmp[index++] = arr[begin2++];
}
}
while (begin1 <= end1)
{
tmp[index++] = arr[begin1++];
}
while (begin2 <= end2)
{
tmp[index++] = arr[begin2++];
}
memcpy(arr + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}
}6.非递归实现
上面都是基于递归实现的归并排序。归并排序也可以使用非递归实现。
归并排序的非递归（迭代）实现主要依赖于循环来分解和合并数组，而不是递归调用。这种方法避免了递归实现中可能产生的调用栈开销，这在处理非常大的数据集时尤为重要，因为递归调用栈的深度可能会成为性能瓶颈或导致栈溢出错误。
非递归实现需要更复杂的索引和边界处理来确保算法能够正确地遍历数组、分解子数组以及合并它们。这是因为非递归实现必须显式地管理归并过程中的每一步，包括确定哪些子数组需要被归并，以及这些子数组在原始数组中的位置。
1. 初始化：
为临时数组tmp分配了与原始数组arr相同大小的内存空间，用于存储归并过程中的中间结果。
2. 归并过程：
使用一个变量 gap 来控制归并过程中子数组的大小。初始时， gap 被设置为1，表示每个子数组只包含一个元素。 通过一个外层循环， gap 的值在每次迭代后翻倍，直到 gap 大于等于数组的长度 n。这个循环确保了整个数组最终会被归并为一个有序的整体。
3. 遍历和归并子数组：
- 在外层循环内部，使用一个内层循环来遍历数组arr，每次跳过2 * gap个元素，以处理相邻的、大小为gap的子数组对。
- 对于每对子数组，计算它们的起始和结束索引（begin1, end1, begin2, end2）。
- 检查第二组子数组的起始索引 begin2 是否越界。如果是，则跳出内层循环，因为后续的子数组对已经不需要归并了（它们要么已经是有序的单个元素，要么已经在此前的迭代中被归并）。
- 如果第二组子数组的结束索引 end2 越界，则将其修正为 n - 1 ，以确保不会访问数组的越界元素。
- 使用一个临时索引 j 来追踪 tmp 数组中当前应该写入的位置。
- 通过一个内部循环，将两个子数组中的元素逐个比较并复制到 tmp 数组中，直到其中一个子数组的所有元素都被复制完毕。
- 然后，将剩余的元素（如果有的话）从另一个子数组复制到tmp数组中。
- 使用 memcpy 函数将归并后的结果从 tmp 数组复制回 arr 数组的相应位置。注意这里复制的长度是 end2 - i + 1 ，它包括了第二个子数组可能因越界而缩短的部分。
来看个图或许好理解很多：
代码实现如下：
void MergeSortNonR(int* arr, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail:");
return;
}
// gap为每组归并数据的个数，初始化为1
int gap = 1;
// 当gap小于数组长度时，继续归并过程
while (gap < n)
{
// 遍历数组，每次跳过2*gap个元素
// 以处理相邻的、大小为gap的子数组对
for (int i = 0; i < n; i += 2 * gap)
{
int begin1 = i;
// 计算第一组子数组的结束索引
int end1 = i + gap - 1;
// 计算第二组子数组的起始索引
int begin2 = i + gap;
// 计算第二组子数组的结束索引
int end2 = i + 2 * gap - 1;
//如果第二组的两个索引都越界，这组不需要归并
if (begin2 >= n)
{
break;
}
//如果第二组的begin2没越界
//end2越界，则需要修正一下
//继续归并
if (end2 >= n)
{
end2 = n - 1;
}
int j = i;
while (begin1 <= end1 && begin2 <= end2)
{
// 从两个子数组中取出较小的元素放入tmp数组
if (arr[begin1] < arr[begin2])
{
tmp[j++] = arr[begin1++];
}
else
{
tmp[j++] = arr[begin2++];
}
}
// 如果第一组子数组还有剩余元素，将它们复制到tmp数组
while (begin1 <= end1)
{
tmp[j++] = arr[begin1++];
}
// 如果第二组子数组还有剩余元素，将它们复制到tmp数组
while (begin2 <= end2)
{
tmp[j++] = arr[begin2++];
}
memcpy(arr + i, tmp + i, sizeof(int) * (end2 - i + 1));
}
// 将gap翻倍，为下一轮归并准备更大的子数组
gap *= 2;
}
free(tmp);
tmp = NULL;
}
7.应用场景
大数据集排序：当需要处理的数据量非常大时，归并排序由于其稳定的性能和较好的可扩展性，成为一种理想的排序选择。它可以很容易地并行化，以提高在多核处理器上的执行效率。
外部排序：当数据集太大，无法一次性装入内存时，归并排序特别有用。它可以在排序过程中分批次读取数据到内存中，对每批次数据进行排序，然后将排序后的数据写入到外部存储设备（如硬盘）。最后，通过归并这些已排序的数据块来完成整个数据集的排序。
数据库和文件系统的索引构建：在构建数据库或文件系统的索引时，归并排序可以用于对索引条目进行排序，从而加速数据的查找、插入和删除操作。
并发编程：在多线程或分布式系统中，归并排序可以很容易地并行化。每个线程或进程可以独立地排序数据的一部分，然后合并结果。
结束语
本篇博客学习排序中的一重要排序：归并排序。
求点赞收藏评论关注！！！
感谢！！！
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
