归并排序递归实现
归并排序,Merge sort,归并排序通过分治法将问题分解为更小的子问题,然后递归地解决这些子问题,最后将它们合并成一个完全有序的序列。
具体步骤:
- 分解(Divide):将n个元素分成n/2个含有n/2个元素的子序列。
- 解决(Conquer):对这两个子序列递归地进行排序。
- 合并(Combine):将两个已排序的子序列合并成一个有序的序列。
代码实现:
void _MergeSort(int* a, int begin, int end, int* tmp)
{
if (begin>=end)
return;
int mid = (end + begin) / 2;
_MergeSort(a, begin, mid, tmp);
_MergeSort(a, mid+1, end, tmp);
int begin1 = begin, end1 = mid;
int begin2 = mid+1, end2 = end;
int i = begin;
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++];
}
memcpy(a + begin, tmp + begin, sizeof(int)* (end - begin + 1));
}
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(n * sizeof(int));
if (!tmp)
{
perror("malloc fail");
return;
}
_MergeSort(a, 0, n - 1, tmp);
free(tmp);
}
性能分析:
通过对上述步骤分析,我们不难发现归并排序的递归深度为
l
o
g
N
logN
logN,且每层需要进行的
N
N
N次遍历。则归并排序的时间复杂度是标准的
O
(
N
l
o
g
N
)
O(NlogN)
O(NlogN)。
但是归并排序的空间复杂度为
O
(
N
)
O(N)
O(N),这是相比较于快速排序和堆排序的一大劣势所在。
还有转折,快速排序和堆排序只能实现内排序,而归并排序不仅可以实现内排序还多用于外排序。
归并排序非递归实现
归并排序的递归过程是将区间不断二分,最终区间长度为1.那么非递归实现可以相反着来。
先以长度为1的数组,两两合并。再将长度不断×2,直至大于原数组长度。
具体代码实现如下:
void MergeNonRSort(int* a, int n)
{
int gap = 1;
int* tmp = (int*)malloc(sizeof(int) * n);
if (!tmp)
{
perror("malloc fail");
return;
}
while (gap < n)
{
for (int j = 0; j < n; j += 2 * gap)
{
int begin1 = j, end1 = j + gap - 1;
int begin2 = j + gap, end2 = j + 2 * gap - 1;
if (end1 >= n - 1 || begin2 >= n)
break;
if (end2 >= n)
end2 = n - 1;
int i = j;
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++];
}
memcpy(a + j, tmp + j, sizeof(int) * (end2 - j + 1));
}
gap *= 2;
}
}
可以看出,上述代码归并的部分和递归实现的完全一致。唯一的难点在于控制分解的两个区间不要越界。