归并排序(Merge sort)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。
递归版本
算法步骤
将序列分成两个子序列,分别将两个子序列排序,然后使用尾插的方法将两个序列有序的合并到tmp数组中,然后再将tmp数组拷贝到原数组。
而上面只是并归排序的其中一步,因为序列要不断的递归二分,直到迭代的时候才合并。
动图演示
静图演示
代码实现
void _MergeSort(int* a, int begin, int end, int* tmp){
if(begin >= end){
return;//递归出口
}
int mid = begin + ((end - begin) >> 1);//将序列分成左右两个子序列
_MergeSort(a, begin, mid, tmp);//往下递归子序列
_MergeSort(a, mid + 1, end, tmp);
int left1 = begin, right1 = mid;//开始合并(使用尾插的方法)
int left2 = mid + 1, right2 = end;
int i = begin;
while(left1 <= right1 && left2 <= right2){
if(a[left1] <= a[left2]){
tmp[i++] = a[left1++];
}
else{
tmp[i++] = a[left2++];
}
}
while(left1 <= right1){
tmp[i++] = a[left1++];
}
while(left2 <= right2){
tmp[i++] = a[left2++];
}
memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));//将排序的部分拷贝到原数组
}
void MergeSort(int* a, int n){
int* tmp = (int*)malloc(sizeof(int) * n);
if(tmp == NULL){
perror("malloc fail");
exit(-1);
}
_MergeSort(a, 0, n - 1, tmp);
free(tmp);
tmp = NULL;
}
非递归版本
算法步骤
非递归其实也是在模仿递归的操作,这里是使用的gap来控制每次比较的元素的区间大小,分别用两个下标来控制元素的区间范围。
静图演示
代码实现
void MergeSortNonR(int* a, int n){
int* tmp = (int*)malloc(sizeof(int) * n);
if(tmp == NULL){
perror("malloc fail");
exit(-1);
}
int gap = 1;//用gap来控制每次比较的元素的区间大小
while(gap < n){
for(int i = 0; i < n; i += 2 * gap){
int left1 = i, right1 = i + gap - 1;//用下标来控制区间范围
int left2 = i + gap, right2 = i + 2 * gap - 1;
int j = i;
while(left1 <= right1 && left2 <= right2){
if(a[left1] <= a[left2]){
tmp[j++] = a[left1++];
}
else{
tmp[j++] = a[left2++];
}
}
while(left1 <= right1){
tmp[j++] = a[left1++];
}
while(left2 <= right2){
tmp[j++] = a[left2++];
}
memcpy(a + i, tmp + i, (right2 - i + 1) * sizeof(int));
}
gap *= 2;
}
free(tmp);
tmp = NULL;
}
注意了,在非递归版本中,需要注意的细节非常多,看上图,每次比较时,都正好是2的倍数,所以看不出什么毛病,那如果比较的数据数量是奇数个呢?需要比较的区间数量是奇数个呢?
看,如果出现以上类似的这三种情况,都会导致越界的情况。所以要针对类似的这三种情况做一些特殊处理。
而这三种情况就分别是控制两个区间的后三个下标,而至于left1,left1是绝对不会越界的,所以不用处理left1
void MergeSortNonR(int* a, int n){
int* tmp = (int*)malloc(sizeof(int) * n);
if(tmp == NULL){
perror("malloc fail");
exit(-1);
}
int gap = 1;
while(gap < n){
for(int i = 0; i < n; i += 2 * gap){
int left1 = i, right1 = i + gap - 1;
int left2 = i + gap, right2 = i + 2 * gap - 1;
if(right1 >= n){
break;//说明此时无右区间和左区间合并,所以直接break
}
if(left2 >= n){
break;//说明此时无右区间和左区间合并,所以直接break
}
if(right2 >= n){
right2 = n - 1;//说明此时右区间只有一部分和左区间合并,所以缩短右区间
}
int j = i;
while(left1 <= right1 && left2 <= right2){
if(a[left1] <= a[left2]){
tmp[j++] = a[left1++];
}
else{
tmp[j++] = a[left2++];
}
}
while(left1 <= right1){
tmp[j++] = a[left1++];
}
while(left2 <= right2){
tmp[j++] = a[left2++];
}
memcpy(a + i, tmp + i, (right2 - i + 1) * sizeof(int));//一定是要每次
}
gap *= 2;
}
free(tmp);
tmp = NULL;
}
复杂度、稳定性分析
-
时间复杂度
由于并归排序是递归的类似于二叉树的形状,每次都将序列分为子序列,所以深度就是 l o g N log^{N} logN,而每层都是那N个元素在合并,所以时间复杂度为 O ( N ∗ l o g N ) O(N*log^{N}) O(N∗logN)
-
空间复杂度
由于并归排序需要开辟一段tmp空间来存储排序后的元素,所以空间复杂度为 O ( N ) O(N) O(N)
-
稳定性
稳定