基本思想:
递归实现:
步骤:
1.首先用malloc开辟有n个整型元素的空间,返回其数组首元素指针tmp,用来对数据进
行归并操作,最后再拷贝回原数组。
2.(begin与end分别是待排序数组的首尾元素下标)定义一个mid为数组中间元素下标
mid = (end + begin) / 2,将数组分为左右两部分[begin, mid] [mid+1, end]。
3.进行递归直到无法再分割,(end<=begin)。递归返回时进行归并操作。
4.定义begin1=begin,end1=mid;begin2=mid+1,end2=end其目的是将左右两部分进行
比较。定义一个index = begin,目的是用来访问tmp数组。
5.从begin1与begin2开始依次比较左右两部分的中元素的大小将小的放到tmp中然后
index++;直到左右两部分中有一部分的元素被访问完(begin1 >end1 && begin2 > end2),再
将没有访问完的那个数组放到tmp中。
6.用memcpy将tmp中的数据拷贝回原数组。
代码实现:
//开辟有n个整型元素的空间,其首元素地址为tmp;
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail");
return;
}
_MergeSort(a, tmp, 0, n - 1);
free(tmp);
}
void _MergeSort(int* a, int* tmp, int begin, int end)
{
//递归返回条件:
if (end <= begin)
return;
//递归分割左右两部分
int mid = (end + begin) / 2;
// [begin, mid][mid+1, end]
_MergeSort(a, tmp, begin, mid);
_MergeSort(a, tmp, mid + 1, end);
// 归并到tmp数据组,再拷贝回去
// a->[begin, mid][mid+1, end]->tmp
int begin1 = begin, end1 = mid;
int begin2 = mid + 1, end2 = end;
int index = begin;
//有一个区间被访问完:
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[index++] = a[begin1++];
}
else
{
tmp[index++] = a[begin2++];
}
}
//访问没有被访问完的那个区间;
while (begin1 <= end1)
{
tmp[index++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[index++] = a[begin2++];
}
// 拷贝回原数组
memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}
非递归实现
步骤:
1.用malloc开辟有n个整型元素的空间,返回其数组首元素指针tmp,用来对数据进
行归并操作,最后再拷贝回原数组。
2..定义一个gap来对数据进行左右分割操作来取代递归分割(如图):
3.归并操作与递归式时的描述基本相似。
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 += 2 * gap)
{
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
// [begin1,end1] [begin2,end2] 归并
int index = i;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[index++] = a[begin1++];
}
else
{
tmp[index++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[index++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[index++] = a[begin2++];
}
// 拷贝回原数组
memcpy(a + i, tmp + i, (2*gap) * sizeof(int));
}
gap *= 2;
}
free(tmp);
}
4.此时代码虽然逻辑上没有问题但是也存在这一些边界问题,我们可以举几个范例(如图):
可以将此时9个元素(下标是0到8)分割的区间打印出来,便于我们观察错误:
5.发现问题后,我们应该加入控制边界的代码:
6.最后控制此时memcpy的大小不再是2*gap而是end-i+1即可 。
代码实现:
// 归并排序非递归实现
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 += 2 * gap)
{
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
// [begin1,end1] [begin2,end2] 归并
if (begin2 >= n)
{
break;
}
if (end2 >= n)
{
end2 = n - 1;
}
int index = i;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[index++] = a[begin1++];
}
else
{
tmp[index++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[index++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[index++] = a[begin2++];
}
// 拷贝回原数组
memcpy(a + i, tmp + i, (end2 - i + 1) * sizeof(int));
}
gap *= 2;
}
free(tmp);
}
总结:
1. 归并的缺点在于需要O(N)的空间复杂度,归并排序的思考更多的是解决在磁盘中的外排序问题。