前言:
归并排序跟快速排序有异曲同工之妙,都是分治法的典型代表。但是这种分治法都有不小的弊端,就是需要占用大量的系统栈,很容易造成空间的大量浪费,所以就有用迭代来优化递归的操作。这次的归并排序,我采用迭代的方式来进行编写。
思路:
归并算法如其名,需要不断地归并。我们在学习数组的时候,应该学习到过合并两个有序的数组的时间复杂度是很低的,不断地二分并进行合并,这个算法的时间复杂度仅为O(nlogn),但是合并数组的时候是需要一个额外的相当于原数组大小的空间的,所以空间复杂度并不是很好O(n)
所以最先的最先,我们要先开辟一块空间
int *b = (int*)malloc((length+5) * sizeof(int));
//加上一些偏移量以防越界,同时,要记得最后要free掉这片空间
//这个free不重视要出大问题的,接下来会说
开始写这个排序最先想到的莫非就是如何不断地二分。既然我们选择的是自下而上的进行迭代,我们一开始的1个1个的比较从而形成2个,2个比较的情况,因此我们的两层循环其实就已经都定下来了:(offset是偏移量的意思)
for (offset = 1; offset < length; offset *=2)
for (left = 0; left < length; left += 2 * offset)
由于是二分,所以偏移量自下而上的是1,2,4,8···,也就是说 偏移量的变化是 offset *=2
然后left和接下来的right是在原数组中进行滑动的下标,用来比较的。
接下来,我们需要思考一下left 和right有哪些情况。其实,这里主要的问题就是怕越界,因此我们为了方便表示,重新定义三个变量,来处理可能越界的问题:
int low = left;
int mid = min(left + offset, length);
int high = min(left + 2 * offset, length);
(left+offset 相当于右比较框的第一个元素;left+2*offset 相当于同样长的第三个比较框的第一个元素)
这里的mid,是左边比较框的最右端再往右一个单位,因此可能会超出数组长度,需要在len和left+offset 中选择较小的一个;
这里的mid,同时也是右边比较框的第一个元素,high是右边比较框的最右端再往右一个单位,与上面同理,有可能越界,所以在left + 2 * offset 和 len 选择较小的一个。这样,再为了方便重新定义几个量来表示,就很清晰明了了:
int left1 = low, right1 = mid;
int left2 = mid, right2 = high;
接下来的部分其实比较简单,就是两个有序数组进行比较,并归并入新数组的过程:
//确定指针没跑到下一个区间去
while (left1 < right1 && left2 < right2)
b[i++] = a1[left1] < a1[left2] ? a1[left1++] : a1[left2++];
//下头两个while只执行一个,把剩下的元素全搬进去
while (left1 < right1)
b[i++] = a1[left1++];
while (left2 < right2)
b[i++] = a1[left2++];
当整个数组比较完以后,我们开辟的b数组中,就是合并过一次的数组了,我们需要把a和b换个位置。
int* temp = a1;
a1 = b;
b = temp;
至此呢,大概已经完成了,但是,不注意free要出现的大问题来了:
如果上面那个交换的代码交换了奇数次,如果我们free(b),我们就会free一片静态内存了,这是不被允许的。如下图所示:
为了解决这个问题,我们一开始就需要定义指针来指向空间,最后用来做校验。当然,释放的时候我们为了保险直接释放b1就行了,绝对没问题。
这边我们应该这么写:
if (b != b1)
{
for (int i = 0; i < length; i++)
{
a[i] = a1[i];
}
}
free(b1);
肯定有人会跟我有一样的问题,为什么不能再改变指针的位置直接成功呢?就像下面一样:
if (b != b1)
{
a = a1;
}
free(b1);
这个时候我们用地址找一下,就很容易明白了:
一开始的地址:
处理完的地址:
我们会发现其实他所有的地址全都指向了一开始开辟的,最后要被释放掉的动态区域b!
那么为什么编译器不报错呢?这里应该和我在别处了解到的别的一样:编译器会做一定的保留。
所以并不会直接报错,但是会出现意料之外的情况。因此,我们不能改动地址,而应该用赋值操作,来使a数组,与a1数组同步(像我上面讲的,a1一定是有序的那一个,而我们最后需要的是a数组)
核心代码:
这边的核心代码为了阅读以及复制方便,我就只保留 归并排序 的内容了,我的一些试错及写出来的体验和心得就放在下面的测试代码中了,想具体了解的,可以移步到下面了。
void MergeSort(int *a,int length)
{
int* a1 = a;
int *b = (int*)malloc((length+5) * sizeof(int));
int* b1 = b;
int offset;//offset是每次归并的两个小数组的偏移量
for (offset = 1; offset < length; offset *=2)
{
int left;
int i=0; //i是给新数组准备的下标
for (left = 0; left < length; left += 2 * offset)
{
int low = left, mid = min(left + offset, length), high = min(left + 2 * offset, length);
int left1 = low, right1 = mid;
int left2 = mid, right2 = high;
while (left1 < right1 && left2 < right2)
b[i++] = a1[left1] < a1[left2] ? a1[left1++] : a1[left2++];
while (left1 < right1)
b[i++] = a1[left1++];
while (left2 < right2)
b[i++] = a1[left2++];
}
int* temp = a1;
a1 = b;
b = temp;
}
if (b != b1)
{
for (int i = 0; i < length; i++)
{
a[i] = a1[i];
}
}
free(b1);
}
整体测试代码:
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define N 30
//之前写过了,就不再全写一遍了
void generate_random_number(int*, int, int);
void swap(int*, int*);
//自下而上迭代
void MergeSort(int *a,int length)
{
int* a1 = a;//如果觉得这一步是多余的,那xd你和我一开始觉得一样,但其实这个是必要的!往下看。
int *b = (int*)malloc((length+5) * sizeof(int));
int* b1 = b;
int offset;//offset是每次归并的两个小数组的偏移量
for (offset = 1; offset < length; offset *=2)
{
int left;
int i=0; //i是给新数组准备的下标
//left是每次进行归并的左边小数组,right是右边的;每次归并完两个,整体向右挪动两倍的offset
//注释掉的是写的错的代码。错在没有考虑数组指针越界的情况,其实也就一行 right = min(left+offset,length)
//for (left = 0,right = left + offset,i = 0; left < length && right < length; left += offset * 2, right = left + offset)
//{
// int left1 = left;
// int right1 = right;
// while (right1 < left + 2*offset && left1 < right)//指针没跑到下一个区间去
// {
// if (a[left1] <= a[right1])
// b[i++] = a[left1++];
// else
// b[i++] = a[right1++];
// }
// //下头两个while只执行一个,把剩下的元素全搬进去
// while (left1 < right)
// b[i++] = a[left1++];
// while(right1 < left + 2 * offset)
// b[i++] = a[right1++];
//}
for (left = 0; left < length; left += 2 * offset)
{ //下这两步都是为了确保数组下标不会越界
int low = left, mid = min(left + offset, length), high = min(left + 2 * offset, length);
int left1 = low, right1 = mid;
int left2 = mid, right2 = high;
//确定指针没跑到下一个区间去
while (left1 < right1 && left2 < right2)
b[i++] = a1[left1] < a1[left2] ? a1[left1++] : a1[left2++];
//下头两个while只执行一个,把剩下的元素全搬进去
while (left1 < right1)
b[i++] = a1[left1++];
while (left2 < right2)
b[i++] = a1[left2++];
}
int* temp = a1;
a1 = b;
b = temp;
/* 不容易,我终于想懂了!
上面这一步实现交换,使得有序的序列肯定是a所指的地址,但是最后a的地址不一定能回到arr,可能在b上
但是,free函数只能释放动态开辟的内存,也就是只能释放原先b所指的内存空间,如果释放到a,直接严重弹框报错
外头我画了张图
根据log2(length)算出来的不同值,下面的交换步骤可能只进行奇数次,因此还需要多一些步骤才可以完全实现
如果只进行奇数次的话,我函数传参时传入的虽然是真实地址,但是他指向了我在函数中开辟的临时堆空间。
这块堆空间在函数进行完以后会释放掉,因此如果进行奇数次的话,我们在函数结束以后,原函数的地址是一片未知区域!
如果确定只进行偶数次,是可以不要下面步骤的
*/
}
/*
上面的解释也告诉我们,为什么要在函数开头看似无用的新建一个a变量和b1指向我们传入的和创建的地址,也是我们在最后要保证能找到我们一开始的地址
记录了以后我们可以简便的使用 b != b1 来进行判断。
*/
if (b != b1)
{
for (int i = 0; i < length; i++)
{
a[i] = a1[i];
}
}
free(b1);
}
int main()
{
int arr[N + 10] = { 0 };
generate_random_number(arr, 0, 1024);
MergeSort(arr,N);
printf("MergeSort排序后数列:\n");
for (int i = 0; i < N; i++)
printf("%d ", arr[i]);
printf("\n");
return 0;
}
测试结果:
至此,归并排序完成