归并排序递归与非递归超详细讲解C语言

归并排序（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;
}

复杂度、稳定性分析

1. 时间复杂度

   由于并归排序是递归的类似于二叉树的形状，每次都将序列分为子序列，所以深度就是$lo{g}^N$，而每层都是那N个元素在合并，所以时间复杂度为$O(N\ast lo{g}^N)$

2. 空间复杂度

   由于并归排序需要开辟一段tmp空间来存储排序后的元素，所以空间复杂度为$O(N)$

3. 稳定性

   稳定