归并排序算法（二路）——C/C++

归并排序（二路）

1. 算法思想

归并排序（Merge）是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

2. 实现原理

2.1、申请一个和原始排序数组空间一样大的额外数组。
2.2、定义归并初始长度 length。
2.3、将数组分块。
2.4、将分块数组进行排序，把数据存入额外一个数组。（下一次用额外数组排序，数据存入原始数组，轮流存储）
2.5、增加归并长度 length*2。
2.6、重复3-5步，即可得到排序。

3. 动态演示

网上的和我的想法有点不一样
网上动图都是依次分组，当有有序数组长度一样时归并排序，然后合并。

我认为是先把组分好，在组内排序，然后扩大长度，最后自然合并。

4. 完整代码

4.1 核心函数

合并函数：void merge(int* input, int* output, int start, int mid, int end)
分块函数：void merge_split(int* input, int* output, int length, int size)
排序函数：void merge_sort(int* array1, int size)

4.2 全部代码

#include <stdio.h>
#include <stdlib.h> // rand() srand()
#include <time.h>   // time()

void display(int* array, int size); // 打印函数
int  check(int* array, int size);   // 检查函数

/**
 * @brief 分块数组合并
 *
 * @param input        [in] 输入数组
 * @param output       [out] 输出数组
 * @param start        起始位置
 * @param mid          分割位置
 * @param end          结束位置
 */
void merge(int* input, int* output, int start, int mid, int end)
{
    int i = start;   // 第一块初始下标
    int j = mid + 1; // 第二块初始下标
    int k = start;   // 充当合并块的下标

    // 判断遍历两个分块结束
    while ((i <= mid) && (j <= end)) {
        // 第一块第 i 个值比第二块第 j 值小
        if (input[i] <= input[j]) {
            output[k++] = input[i++]; // 把小的值存入第二个数组，即第一块第 i 个值
        } else {
            output[k++] = input[j++]; // 小的值存入第二个数组，即第二块第 j 个值
        }
    }
    // 第一块没遍历完，而第二块遍历结束，说明第一块剩余值都大于第二块
    while (i <= mid) {
        output[k++] = input[i++]; // 直接把剩余第一块数据都存入第二个数组
    }
    // 第二块没遍历完，而第一块遍历结束，说明第二块剩余值都大于第一块
    while (j <= end) {
        output[k++] = input[j++]; // 直接把剩余第二块数据都存入第二个数组
    }
}

/**
 * @brief 数组分块
 *
 * @param input        [in] 输入数组
 * @param output       [out] 输出数组
 * @param length       归并长度
 * @param size         数组分块大小
 */
void merge_split(int* input, int* output, int length, int size)
{
    int i = 0;
    // 分块
    while (i + 2 * length - 1 < size) {
        merge(input, output, i, i + length - 1, i + 2 * length - 1); // 归并分块排序
        i = i + 2 * length;                                          // 归并间隔，指向下一个分块的起始点
    }

    /**
     * 1. 不足以分成两个完整块
     *      - 前一个满足 length   (i + length - 1) < size - 1
     *      - 后一个小于 length   (i + 2 * length - 1) > size - 1
     * 2. 或者剩下分块小于等于一个分块
     *      - 将剩余数据复制到 output 中
     */
    if ((i + length - 1) < size - 1) {
        merge(input, output, i, i + length - 1, size - 1);
    } else {
        for (int j = i; j < size; j++) {
            output[j] = input[j];
        }
    }
}

/**
 * @brief 归并排序
 *
 * @param array1       数组首指针
 * @param size         数组大小
 */
void merge_sort(int* array1, int size)
{
    int array2[size];
    int length = 1;
    while (length < size) {
        merge_split(array1, array2, length, size); // 归并，结果在 array2 中
        length = 2 * length;                       // 改变归并长度，一般是二路归并
        merge_split(array2, array1, length, size); // 归并，结果在 array1 中
        length = 2 * length;                       // 改变归并长度
    }
}

int main()
{
    // 测试用例
    // int array[]    = {49, 38, 65, 97, 76, 13, 27, 49, 10};
    // int array_size = sizeof(array) / sizeof(array[0]);
    // printf("%d \n", array_size);
    // printf("排序前数组：");
    // display(array, array_size);
    // merge_sort(array, array_size);
    // printf("排序后数组：");
    // display(array, array_size);

    // 随机测试
    int array_num  = 20;             // 数组数量
    int array_size = 20;             // 数组大小
    int array[array_size];           // 数组初始化
    srand((unsigned int)time(NULL)); // 随机数种子，保证每次不一样
    for (int i = 0; i < array_num; i++) {
        for (int j = 0; j < array_size; j++) {
            array[j] = rand() % 1000; // 随机生成数大小 0~999
        }
        printf("原来的数组：");
        display(array, array_size);
        merge_sort(array, array_size);
        printf("排序后数组：");
        display(array, array_size);
        // 检测排序结果
        if (check(array, array_size) != 0) {
            exit(-1);
        }
        printf("\n");
    }

    return 0;
}

/**
 * @brief 打印函数
 *
 * @param array        数组首指针
 * @param size         数组大小
 */
void display(int* array, int size)
{
    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");
}

/**
 * @brief 检查函数，从小到大
 *
 * @param array        数组首指针
 * @param size         数组大小
 */
int check(int* array, int size)
{
    for (int i = 0; i < size - 1; i++) {
        if (array[i] > array[i + 1]) {
            printf("sort array fail...\n");
            return -1;
        }
    }
    printf("sort array success...\n");
    return 0;
}

5. 结果展示

（显示每次排序结果）

6. 算法分析

时间复杂度：

1. 最好：O(n log2 n)
2. 最坏：O(n log2 n)
3. 平均：O(n log2 n)

空间复杂度：O(n)

稳定性：稳定