详解归并排序

凭君语未可2024-12-27 13:10

归并排序

归并排序的基本概念

归并排序（Merge Sort）是一种经典的分治算法 。它将一个大问题分解成若干个小问题，递归地解决这些小问题，然后再合并成一个解决的大问题。归并排序的核心在于合并过程，即将两个已排序的子数组合并成一个有序的数组。

归并排序的详细步骤

1. 分解阶段

归并排序首先将数组分成两半，直到每个子数组中只有一个元素。对于每个子数组，显然它已经是"有序"的（因为一个元素是有序的）。这一步是递归进行的，直到数组被分割到最小的子数组。

举个例子，假设我们有一个数组：

复制代码 
[38, 27, 43, 3, 9, 82, 10]

  • 第一步：将数组从中间拆分成两部分：

    复制代码 
    [38, 27, 43] 和 [3, 9, 82, 10]

  • 第二步：继续拆分，直到每个子数组只有一个元素：

    复制代码 
    [38] 和 [27, 43] 和 [3, 9] 和 [82, 10]

  • 继续拆分：

    复制代码 
    [38] 和 [27] 和 [43] 和 [3] 和 [9] 和 [82] 和 [10]

此时每个子数组只有一个元素，递归的分解阶段就完成了。

2. 合并阶段

合并的过程是归并排序的核心。合并阶段的目的是将每两个已排序的子数组合并成一个新的有序数组。合并时，需要依次比较两个子数组的元素，选择较小的元素放入最终的数组中，直到两个子数组的元素都被合并到结果数组中。

合并时的步骤如下：

  1. 合并 [27] 和 [43]：

    • 比较 27 和 43，先将较小的 27 放入合并数组中，接着将 43 放入合并数组中。
    • 结果：[27, 43]

  2. 合并 [3] 和 [9]：

    • 比较 3 和 9，先将 3 放入合并数组中，接着将 9 放入合并数组中。
    • 结果：[3, 9]

  3. 合并 [82] 和 [10]：

    • 比较 82 和 10，先将较小的 10 放入合并数组中，接着将 82 放入合并数组中。
    • 结果：[10, 82]

经过这些合并后，我们得到如下数组：

复制代码 
[38] 和 [27, 43] 和 [3, 9] 和 [10, 82]

接下来，我们继续合并数组：

  • 合并 [38] 和 [27, 43]：

    • 比较 38 和 27，将 27 放入合并数组中，接着比较 38 和 43，将 38 放入合并数组中，然后将 43 放入合并数组中。
    • 结果：[27, 38, 43]

  • 合并 [3, 9] 和 [10, 82]：

    • 比较 3 和 10，将 3 放入合并数组中，接着比较 9 和 10，将 9 放入合并数组中，然后将 10 和 82 依次放入合并数组中。
    • 结果：[3, 9, 10, 82]

最后，我们合并这两个数组：

  • 合并 [27, 38, 43] 和 [3, 9, 10, 82]：
    • 比较 27 和 3，将 3 放入合并数组中，接着比较 27 和 9，将 9 放入合并数组中，再比较 27 和 10，将 10 放入合并数组中，然后依次放入 27、38、43 和 82。
    • 结果：[3, 9, 10, 27, 38, 43, 82]

到此为止，整个数组已经排好序了。

3. 归并排序的递归流程

归并排序的递归过程非常重要，以下是归并排序的基本逻辑：

  1. 分解：将数组不断拆分，直到每个子数组的长度为 1。
  2. 合并：将两个已排序的子数组合并成一个有序数组。

递归终止条件是数组的大小为 1，此时已经是有序的，我们就不需要进一步分解了。

时间复杂度分析

归并排序的时间复杂度主要由两个因素决定：

  1. 分解阶段 ：每一次递归将数组分成两半，因此分解的深度是 log₂ n 。
  2. 合并阶段 ：每次合并操作需要线性时间 O(n) ，即每个元素都需要被访问和合并一次。

因此，总的时间复杂度是 O(nlog₂ n) ，其中 n 是待排序数组的长度。这个时间复杂度在最坏、最好和平均情况下都是相同的。

空间复杂度分析

归并排序需要额外的空间来存储临时数组（用于合并操作）。每次合并操作需要使用一个大小为 O(n) 的临时数组，因此归并排序的空间复杂度是 O(n) ，这是它的一个缺点。

算法步骤

2-路归并排序

2-路归并排序将 R[low...high] 中的记录归并排序后放入T[low...high] 中。当序列长度等于1时，递归结束，否则：

  1. 将当前序列一分为二，求出分裂点 mid = ⌊(low + high) / 2⌋ ；
  2. 对子序列 R[low...mid] 递归进行归并排序，结果放入 S[low...mid] 中；
  3. 对子序列 R[mid + 1...high] 递归进行归并排序，结果放入 S[mid + 1...high] 中；
  4. 调用算法Merge，将有序的两个子序列 S[low...mid] 和 S[mid + 1...high] 归并为一个有序的序列 T[low...high] 。

代码分析

c 复制代码 
#include <stdio.h>

// 合并两个子数组
void merge(int arr[], int left, int mid, int right) {
    int n1 = mid - left + 1;  // 计算左子数组的大小
    int n2 = right - mid;     // 计算右子数组的大小
    
    // 创建临时数组
    int leftArr[n1], rightArr[n2];
    
    // 将数据复制到临时数组
    for (int i = 0; i < n1; i++)
        leftArr[i] = arr[left + i];
    for (int j = 0; j < n2; j++)
        rightArr[j] = arr[mid + 1 + j];
    
    int i = 0, j = 0, k = left;
    
    // 合并两个临时数组到原数组
    while (i < n1 && j < n2) {
        if (leftArr[i] <= rightArr[j]) {
            arr[k] = leftArr[i];
            i++;
        } else {
            arr[k] = rightArr[j];
            j++;
        }
        k++;
    }
    
    // 将剩余的元素拷贝到原数组
    while (i < n1) {
        arr[k] = leftArr[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = rightArr[j];
        j++;
        k++;
    }
}

// 递归进行归并排序
void mergeSort(int arr[], int left, int right) {
    if (left < right) {
        // 计算中间点
        int mid = left + (right - left) / 2;
        
        // 递归排序左半部分
        mergeSort(arr, left, mid);
        // 递归排序右半部分
        mergeSort(arr, mid + 1, right);
        // 合并已排序的部分
        merge(arr, left, mid, right);
    }
}

// 打印数组的函数
void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++)
        printf("%d ", arr[i]);
    printf("\n");
}

int main() {
    int arr[] = {38, 27, 43, 3, 9, 82, 10};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    printf("排序前的数组:\n");
    printArray(arr, n);
    
    mergeSort(arr, 0, n - 1);  // 调用归并排序
    
    printf("排序后的数组:\n");
    printArray(arr, n);
    
    return 0;
}

代码讲解

1. 合并两个子数组的函数 merge()
c 复制代码 
void merge(int arr[], int left, int mid, int right) {
  • merge() 函数的目的是将两个已经排好序的子数组合并成一个有序的数组。
  • arr[] 是待排序的数组，left 是左子数组的起始索引，mid 是中间索引，right 是右子数组的结束索引。
c 复制代码 
    int n1 = mid - left + 1;  // 计算左子数组的大小
    int n2 = right - mid;     // 计算右子数组的大小
  • n1 和 n2 分别是左子数组和右子数组的元素个数。
c 复制代码 
    int leftArr[n1], rightArr[n2];
  • leftArr[] 和 rightArr[] 是临时数组，用于存储左子数组和右子数组的元素。
c 复制代码 
    for (int i = 0; i < n1; i++)
        leftArr[i] = arr[left + i];
    for (int j = 0; j < n2; j++)
        rightArr[j] = arr[mid + 1 + j];
  • 将 arr[] 数组中的数据分别复制到 leftArr[] 和 rightArr[] 中。
c 复制代码 
    int i = 0, j = 0, k = left;
  • i 用于遍历 leftArr[]，j 用于遍历 rightArr[]，k 用于遍历原始数组 arr[]。
c 复制代码 
    while (i < n1 && j < n2) {
        if (leftArr[i] <= rightArr[j]) {
            arr[k] = leftArr[i];
            i++;
        } else {
            arr[k] = rightArr[j];
            j++;
        }
        k++;
    }
  • 合并 leftArr[] 和 rightArr[] 的元素到 arr[] 中：
    • 比较 leftArr[i] 和 rightArr[j]，将较小的元素放入 arr[k] 中。
    • 如果左子数组的元素小或相等，就将左子数组的元素放入 arr[k]，否则将右子数组的元素放入。
c 复制代码 
    while (i < n1) {
        arr[k] = leftArr[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = rightArr[j];
        j++;
        k++;
    }
  • 如果左子数组或右子数组中还有剩余元素，继续将它们放入 arr[] 中。
2. 归并排序函数 mergeSort()
c 复制代码 
void mergeSort(int arr[], int left, int right) {
  • mergeSort() 函数负责将数组不断分割并排序。它的作用是将数组拆分成越来越小的子数组，直到每个子数组只有一个元素，然后调用 merge() 合并已排序的子数组。
c 复制代码 
    if (left < right) {
  • 递归终止条件：如果左边索引小于右边索引，说明子数组包含多于一个元素，继续分割和排序。
c 复制代码 
        int mid = left + (right - left) / 2;  // 计算中间点
  • 计算中间点 mid，将数组分割成左右两部分。
c 复制代码 
        mergeSort(arr, left, mid);  // 递归排序左半部分
        mergeSort(arr, mid + 1, right);  // 递归排序右半部分
  • 递归调用 mergeSort() 来分别排序左半部分和右半部分。
c 复制代码 
        merge(arr, left, mid, right);  // 合并已排序的部分
  • 合并左右两部分，最终形成一个有序数组。
3. 打印数组的函数 printArray()
c 复制代码 
void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++)
        printf("%d ", arr[i]);
    printf("\n");
}
  • printArray() 用于打印数组中的元素。size 是数组的长度，arr[] 是待打印的数组。
4. 主函数 main()
c 复制代码 
int main() {
    int arr[] = {38, 27, 43, 3, 9, 82, 10};
    int n = sizeof(arr) / sizeof(arr[0]);
  • 定义一个待排序的数组 arr[]，并通过 sizeof(arr) / sizeof(arr[0]) 计算数组的长度 n。
c 复制代码 
    printf("排序前的数组:\n");
    printArray(arr, n);
  • 打印排序前的数组。
c 复制代码 
    mergeSort(arr, 0, n - 1);  // 调用归并排序
  • 调用 mergeSort() 函数进行排序。
c 复制代码 
    printf("排序后的数组:\n");
    printArray(arr, n);
  • 打印排序后的数组。

归并排序的稳定性

归并排序是一种稳定的排序算法。稳定性意味着如果两个元素的值相同，排序后它们在原数组中的相对顺序不会改变。

归并排序的优缺点

优点：

  1. 时间复杂度稳定 ：归并排序的时间复杂度始终为 O(nlog₂ n) ，无论是最坏、平均还是最好情况都一样。
  2. 稳定性 ：它是一种 稳定 的排序算法，对于相等的元素，能保持它们的相对顺序。
  3. 适用于大数据集：归并排序在处理大数据集时非常有效，尤其是在外部排序中。

缺点：

  1. 空间复杂度较高 ：归并排序需要 O(n) 的额外空间，这比其他一些排序算法如快速排序要高。
  2. 不适用于小数据集：对于小规模数据，归并排序相比于插入排序、选择排序等简单的排序算法可能并不高效。
  3. 合并操作需要额外时间：每次合并操作需要处理所有元素，因此合并阶段的时间开销相对较大。
相关推荐
一念&5 小时前
每日一个C语言知识：C 头文件
c语言·开发语言·算法
Miraitowa_cheems8 小时前
LeetCode算法日记 - Day 88: 环绕字符串中唯一的子字符串
java·数据结构·算法·leetcode·深度优先·动态规划
B站_计算机毕业设计之家9 小时前
python电商商品评论数据分析可视化系统 爬虫 数据采集 Flask框架 NLP情感分析 LDA主题分析 Bayes评论分类（源码） ✅
大数据·hadoop·爬虫·python·算法·数据分析·1024程序员节
小白菜又菜10 小时前
Leetcode 1518. Water Bottles
算法·leetcode·职场和发展
长存祈月心10 小时前
Rust Option 与 Result深度解析
算法
杭州杭州杭州10 小时前
机器学习(3)---线性算法，决策树，神经网络，支持向量机
算法·决策树·机器学习
不语n12 小时前
快速排序（Quick Sort）详解与图解
数据结构·算法·排序算法·快速排序·双指针排序
电鱼智能的电小鱼12 小时前
基于电鱼 ARM 工控机的AI视频智能分析方案：让传统监控变得更聪明
网络·arm开发·人工智能·嵌入式硬件·算法·音视频
初学者，亦行者12 小时前
Rust性能优化：内存对齐与缓存友好实战
算法·rust
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03BongoCat - 跨平台键盘猫动画工具04Linux下V2Ray安装配置指南05GitLab 零基础入门指南：从安装到项目管理全流程06NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南07Labelme从安装到标注：零基础完整指南08安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）10jdk21下载、安装（Windows、Linux、macOS）