如何让两个有序数组合并成一个有序数组呢?在顺序表的学习阶段,我们学过合并两个有序链表,用两个指针依次遍历这两个链表,取值小的节点尾插,合并有序数组与之类似,但是需要创建一个新的数组。为了解决此类问题,我们引入了归并排序这种算法。
什么是归并排序?
归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。
如何实现?
递归实现过程图解
开辟一个新数组空间tmp用于存放合并后序列。采用分治的思想,要想使序列有序,序列的左右两序列都要有序;左序列要有序,左序列的左右序列都应有序;...;依次往下分,即最后分成单个的数,再将单个的数两两归并,合成一组,对形成的新组再进行两两归并,直到只剩一组就结束。
递归代码实现
void _MergeSort(int* a, int begin, int end, int* tmp)
{
if (begin <= end)
return;
int mid = (end - begin) / 2;
int begin1 = begin;
int end1 = mid - 1;
int begin2 = mid;
int end2 = end;
_MergeSort(a, begin1, end1, tmp);
_MergeSort(a, begin2, end2, tmp);
int i = 0;
while (begin1 <= end1 && begin2 <= end2)
{
if(a[begin1] < a[begin2])
tmp[i++] = a[begin1++];
else
tmp[i++] = a[begin2++];
}
while (begin1 <= end1)
{
tmp[i++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[i++] = a[begin2++];
}
memcmp(a + begin, tmp + begin, sizeof(int) *(end - begin + 1));
}
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail");
return;
}
_MergeSort(a, 0, n - 1, tmp);
free(tmp);
}
非递归实现过程图解
用哪种方法实现归并排序的非递归更合适呢?在实现快排时我们选择了用栈实现,因为快速排序类似于二叉树的前序遍历结构,每一次出栈的区间经一次单趟排序后获得一个下标key,key左边都是小于key的数,右边都是大于key的数,再将新的区间压栈重复操作,实质上不存在递归就达到了效果。归并排序若采用此方法便达不到效果,归并类似于后序,如果返回去,上一个区间就找不到了,因为已经被出栈了。
那么归并的非递归应该怎么实现呢?
我们可以将采用分组的方式,每次把两组数进行排序然后放入新建数组tmp,后拷贝到原数组中去。组的大小是变化的,开始时组大小为1。记得最后释放掉开辟的空间哦!
我们用gap来表示数组的长度,gap从1开始 ,对长度为gap的两个数组进行归并。区间为[begin1,end1] [begin2,end2]。在每一趟归并后更新gap值,gap *= 2。
以下列数据为例:
还有一个问题就是这两个区间一定大小相同吗?或者说同时存在? 上图中的例子中数据个数恰好是2的次方个,所以不管gap是何值一定会存在两个可以归并的区间。为排除偶然性,所以我们要考虑区间的范围。begin1,end1,begin2,end2 这四个数中只有 begin1 不会越界,因为当 begin1 >= n 时就停止了。
end1 = begin1 + gap - 1 [begin1,end1]间有gap个数据
begin2 = begin1 + gap begin2和begin1间隔了一个大小为gap的数组
end2 = begin2 + gap - 1 [begin2,end2]间有gap个数据
(1)当 end1 越界时,begin2 和 end2 也肯定越界了,只存在区间[begin1,end1],区间本身已经有序,所以不用排序;
(2)当 begin2 越界时,还是说明只存在区间[begin1,end1],仍不需要排序
(3)当 end2 越界时,虽然两个区间大小不相等,但是还是需要进行归并,此时需要更新 end2 的值,令 end2 = n - 1(n为数据总个数)
非递归代码实现
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail");
return;
}
int gap = 1;
while (gap < n)
{
for (int i = 0; i < n; i += gap)
{
int begin1 = i;
int end1 = i + gap - 1;
int begin2 = i + gap;
int end2 = i + gap * 2 - 1;
//处理数组边界越界问题
if (end1 >= n || begin2 >= n)
{
break;
}
if (end2 >= n)
end2 = n - 1;
int j = begin1;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
tmp[j++] = a[begin1++];
else
tmp[j++] = a[begin2++];
}
while (begin1 <= end1)
{
tmp[j++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[j++] = a[begin2++];
}
memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
}
gap *= 2;
}
free(tmp);
}
总结
1. 归并的缺点在于需要O(N)的空间复杂度,归并排序的思考更多的是解决在磁盘中的外排序问题。2. 时间复杂度:O(N*logN)3. 空间复杂度:O(N)4. 稳定性:稳定