数组排序01｜归并排序：分治法的经典应用

数组排序01｜归并排序：分治法的经典应用

归并排序是一种经典的排序算法，它属于“分治法”的一种。归并排序的基本思想是将一个大问题分解成若干个小问题，分别解决这些小问题，然后将结果合并起来，最终解决整个大问题。在归并排序中，这个过程是通过将一个数组分成两个子数组，分别对这两个子数组进行排序，然后将它们合并成一个有序的数组来实现的。

归并排序的详细步骤

1. 分解数组：

• 将数组分成两个子数组，分别是左半部分和右半部分。

2. 递归排序：

• 对左半部分进行递归排序。
• 对右半部分进行递归排序。
• 继续将每个子数组分成更小的子数组，直到每个子数组的长度为1或0，此时这些子数组已经是有序的。

3. 合并有序子数组：

• 将两个有序的子数组合并成一个有序的数组。

实现代码

以下是归并排序的实现代码示例：

// 合并两个有序数组到一个数组中
void merge(int *array, int *left, int left_size, int *right, int right_size) {
    int i = 0, j = 0, k = 0;
    // 合并两个有序数组，若有一个数组已经合并完，则结束循环
    while (i < left_size && j < right_size) {
        if (left[i] < right[j]) {
            array[k++] = left[i++];
        } else {
            array[k++] = right[j++];
        }
    }
    // 处理剩余的左边数组元素
    while (i < left_size) {
        array[k++] = left[i++];
    }
    // 处理剩余的右边数组元素
    while (j < right_size) {
        array[k++] = right[j++];
    }
}

// 归并排序函数
int *merge_sort(int *array, int size) {
    // 如果数组长度小于等于1，直接返回数组
    if (size <= 1) {
        return array;
    }

    // 计算左右子数组的大小
    int left_size = size / 2;
    int right_size = size - left_size;
    // 分配左右子数组的内存
    int *left = (int*)malloc(sizeof(int) * left_size);
    int *right = (int*)malloc(sizeof(int) * right_size);

    // 将原数组的元素复制到左右子数组中
    for (int i = 0; i < left_size; i++) {
        left[i] = array[i];
    }
    for (int i = 0; i < right_size; i++) {
        right[i] = array[i + left_size];
    }

    // 递归调用归并排序函数
    left = merge_sort(left, left_size);
    right = merge_sort(right, right_size);

    // 合并排序后的左右子数组
    merge(array, left, left_size, right, right_size);

    // 释放左右子数组的内存
    free(left);
    free(right);

    return array;
}

归并排序的优化方案

归并排序是一种非常高效的排序算法，但针对不同的应用场景，我们可以通过一些优化方案来进一步提升其性能。这些优化方案主要包括减少递归调用的开销、优化内存使用以及结合其他排序算法等。以下是一些常见的优化方案：

1. 优化小数组排序（借鉴尾递归优化的思路）

对于较小的数组，插入排序的性能通常优于归并排序。这是因为插入排序没有递归调用的开销，并且在处理小数组时，其简单的比较和交换操作更加高效。因此，我们可以设置一个阈值，当数组长度小于该阈值时，使用插入排序代替递归调用归并排序。

#define INSERTION_SORT_THRESHOLD 16

// 插入排序函数
void insertion_sort(int *array, int size) {
    for (int i = 1; i < size; i++) {
        int key = array[i];
        int j = i - 1;
        // 将当前元素插入到已排序部分的正确位置
        while (j >= 0 && array[j] > key) {
            array[j + 1] = array[j];
            j--;
        }
        array[j + 1] = key;
    }
}

// 归并排序函数
int *merge_sort(int *array, int size) {
    // 如果数组长度小于等于阈值，使用插入排序
    if (size <= INSERTION_SORT_THRESHOLD) {
        insertion_sort(array, size);
        return array;
    }

    // 归并排序的其余部分保持不变
}

2. 优化内存使用，减少不必要的内存分配

在归并排序中，每次递归调用都会分配新的内存来存储左右子数组。这种频繁的内存分配和释放会增加开销，影响排序的性能。为了优化这一点，可以预先分配一个辅助数组，并在整个排序过程中重复使用这个数组，从而减少内存分配的次数。

// 合并两个有序数组到一个数组中
void merge(int *array, int *temp, int left, int mid, int right) {
    int i = left, j = mid + 1, k = left;
    // 合并两个有序数组，若有一个数组已经合并完，则结束循环
    while (i <= mid && j <= right) {
        if (array[i] <= array[j]) {
            temp[k++] = array[i++];
        } else {
            temp[k++] = array[j++];
        }
    }
    // 处理剩余的左边数组元素
    while (i <= mid) {
        temp[k++] = array[i++];
    }
    // 处理剩余的右边数组元素
    while (j <= right) {
        temp[k++] = array[j++];
    }
    // 将排序后的结果复制回原数组
    for (i = left; i <= right; i++) {
        array[i] = temp[i];
    }
}

// 递归归并排序函数
void merge_sort_recursive(int *array, int *temp, int left, int right) {
    // 如果子数组长度小于等于阈值，使用插入排序
    if (right - left <= INSERTION_SORT_THRESHOLD) {
        insertion_sort(array + left, right - left + 1);
        return;
    }

    int mid = (left + right) / 2;
    // 递归排序左半部分
    merge_sort_recursive(array, temp, left, mid);
    // 递归排序右半部分
    merge_sort_recursive(array, temp, mid + 1, right);
    // 合并排序后的左右子数组
    merge(array, temp, left, mid, right);
}

// 归并排序函数
void merge_sort(int *array, int size) {
    // 分配辅助数组的内存
    int *temp = (int*)malloc(sizeof(int) * size);
    // 调用递归归并排序函数
    merge_sort_recursive(array, temp, 0, size - 1);
    // 释放辅助数组的内存
    free(temp);
}

3. 自底向上的归并排序

自底向上的归并排序是一种非递归的归并排序算法。它通过迭代的方式逐步合并子数组，从最小的子数组开始，直到整个数组有序。与自顶向下的递归归并排序不同，自底向上的归并排序避免了递归调用的开销。

1. 初始化子数组大小：

• 从大小为1的子数组开始，每次将子数组大小加倍（1, 2, 4, 8, …），直到子数组大小大于或等于数组长度。

2. 合并子数组：

• 对于当前子数组大小，将数组分成多个子数组对，每对子数组进行合并。
• 合并后的子数组大小是当前子数组大小的两倍。

3. 重复步骤2：

• 继续合并子数组，直到整个数组有序。

// 自底向上的归并排序函数
void merge_sort_bottom_up(int *array, int size) {
    // 分配一个与原数组大小相同的辅助数组
    int *temp = (int*)malloc(sizeof(int) * size);
    // 子数组大小从1开始，每次加倍
    for (int width = 1; width < size; width *= 2) {
        // 按当前子数组大小进行合并
        for (int i = 0; i < size; i += 2 * width) {
            int left = i;               // 左子数组的起始索引
            int mid = i + width - 1;    // 左子数组的结束索引
            // 右子数组的结束索引
            int right = (i + 2 * width - 1 < size) ? (i + 2 * width - 1) : (size - 1);
            // 如果右子数组存在，则进行合并
            if (mid < right) {
                merge(array, temp, left, mid, right);
            }
        }
    }
    // 释放辅助数组的内存
    free(temp);
}