【数据结构】排序算法---归并排序

news2025/11/4 19:15:02

在这里插入图片描述

文章目录

  • 1. 定义
  • 2. 算法步骤
  • 3. 动图演示
  • 4. 性质
  • 5. 算法分析
  • 6. 代码实现
    • C语言——迭代版
    • C语言——递归版
    • Python
    • Java
    • C++——迭代版
    • C++——递归版
    • Go
  • 结语

1. 定义

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

作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：

  • 自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；
  • 自下而上的迭代；

2. 算法步骤

  • 把长度为n的输入序列分成两个长度为n/2的子序列；
  • 对这两个子序列分别采用归并排序；
  • 将两个排序好的子序列合并成一个最终的排序序列。

在这里插入图片描述

3. 动图演示

在这里插入图片描述

4. 性质

稳定性：

归并排序是高效的基于比较的稳定排序算法。

空间复杂度：

归并排序可以只使用 O ( 1 ) O(1) O(1)大小的辅助空间，但为便捷通常使用与原数组等长的辅助数组。所以通常情况下空间复杂度为 O ( n ) O(n) O(n)

时间复杂度：

归并排序基于分治思想将数组分段排序后合并，时间复杂度在最优、最坏与平均情况下均为 O ( n l o g n ) O(nlogn) O(nlogn)。

5. 算法分析

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是 O ( n l o g n ) O(nlogn) O(nlogn)的时间复杂度。代价是需要额外的内存空间。

6. 代码实现

C语言——迭代版

int min(int x, int y) {
    return x < y ? x : y;
}
void merge_sort(int arr[], int len) {
    int *a = arr;
    int *b = (int *) malloc(len * sizeof(int));
    int seg, start;
    for (seg = 1; seg < len; seg += seg) {
        for (start = 0; start < len; start += seg * 2) {
            int low = start, mid = min(start + seg, len), high = min(start + seg * 2, len);
            int k = low;
            int start1 = low, end1 = mid;
            int start2 = mid, end2 = high;
            while (start1 < end1 && start2 < end2)
                b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
            while (start1 < end1)
                b[k++] = a[start1++];
            while (start2 < end2)
                b[k++] = a[start2++];
        }
        int *temp = a;
        a = b;
        b = temp;
    }
    if (a != arr) {
        int i;
        for (i = 0; i < len; i++)
            b[i] = a[i];
        b = a;
    }
    free(b);
}

C语言——递归版

void merge_sort_recursive(int arr[], int reg[], int start, int end) {
    if (start >= end)
        return;
    int len = end - start, mid = (len >> 1) + start;
    int start1 = start, end1 = mid;
    int start2 = mid + 1, end2 = end;
    merge_sort_recursive(arr, reg, start1, end1);
    merge_sort_recursive(arr, reg, start2, end2);
    int k = start;
    while (start1 <= end1 && start2 <= end2)
        reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
    while (start1 <= end1)
        reg[k++] = arr[start1++];
    while (start2 <= end2)
        reg[k++] = arr[start2++];
    for (k = start; k <= end; k++)
        arr[k] = reg[k];
}

void merge_sort(int arr[], const int len) {
    int reg[len];
    merge_sort_recursive(arr, reg, 0, len - 1);
}

Python

def mergeSort(arr):
    import math
    if(len(arr)<2):
        return arr
    middle = math.floor(len(arr)/2)
    left, right = arr[0:middle], arr[middle:]
    return merge(mergeSort(left), mergeSort(right))

def merge(left,right):
    result = []
    while left and right:
        if left[0] <= right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0));
    while left:
        result.append(left.pop(0))
    while right:
        result.append(right.pop(0));
    return result

Java

public class MergeSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        if (arr.length < 2) {
            return arr;
        }
        int middle = (int) Math.floor(arr.length / 2);

        int[] left = Arrays.copyOfRange(arr, 0, middle);
        int[] right = Arrays.copyOfRange(arr, middle, arr.length);

        return merge(sort(left), sort(right));
    }

    protected int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        int i = 0;
        while (left.length > 0 && right.length > 0) {
            if (left[0] <= right[0]) {
                result[i++] = left[0];
                left = Arrays.copyOfRange(left, 1, left.length);
            } else {
                result[i++] = right[0];
                right = Arrays.copyOfRange(right, 1, right.length);
            }
        }

        while (left.length > 0) {
            result[i++] = left[0];
            left = Arrays.copyOfRange(left, 1, left.length);
        }

        while (right.length > 0) {
            result[i++] = right[0];
            right = Arrays.copyOfRange(right, 1, right.length);
        }

        return result;
    }

}

C++——迭代版

template<typename T> // 整数或浮点数皆可使用,若要使用物件(class)时必须设定"小与"(<)的运算子功能
void merge_sort(T arr[], int len) {
    T *a = arr;
    T *b = new T[len];
    for (int seg = 1; seg < len; seg += seg) {
        for (int start = 0; start < len; start += seg + seg) {
            int low = start, mid = min(start + seg, len), high = min(start + seg + seg, len);
            int k = low;
            int start1 = low, end1 = mid;
            int start2 = mid, end2 = high;
            while (start1 < end1 && start2 < end2)
                b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
            while (start1 < end1)
                b[k++] = a[start1++];
            while (start2 < end2)
                b[k++] = a[start2++];
        }
        T *temp = a;
        a = b;
        b = temp;
    }
    if (a != arr) {
        for (int i = 0; i < len; i++)
            b[i] = a[i];
        b = a;
    }
    delete[] b;
}

C++——递归版

void Merge(vector<int> &Array, int front, int mid, int end) {
    // preconditions:
    // Array[front...mid] is sorted
    // Array[mid+1 ... end] is sorted
    // Copy Array[front ... mid] to LeftSubArray
    // Copy Array[mid+1 ... end] to RightSubArray
    vector<int> LeftSubArray(Array.begin() + front, Array.begin() + mid + 1);
    vector<int> RightSubArray(Array.begin() + mid + 1, Array.begin() + end + 1);
    int idxLeft = 0, idxRight = 0;
    LeftSubArray.insert(LeftSubArray.end(), numeric_limits<int>::max());
    RightSubArray.insert(RightSubArray.end(), numeric_limits<int>::max());
    // Pick min of LeftSubArray[idxLeft] and RightSubArray[idxRight], and put into Array[i]
    for (int i = front; i <= end; i++) {
        if (LeftSubArray[idxLeft] < RightSubArray[idxRight]) {
            Array[i] = LeftSubArray[idxLeft];
            idxLeft++;
        } else {
            Array[i] = RightSubArray[idxRight];
            idxRight++;
        }
    }
}

void MergeSort(vector<int> &Array, int front, int end) {
    if (front >= end)
        return;
    int mid = (front + end) / 2;
    MergeSort(Array, front, mid);
    MergeSort(Array, mid + 1, end);
    Merge(Array, front, mid, end);
}

Go

func mergeSort(arr []int) []int {
        length := len(arr)
        if length < 2 {
                return arr
        }
        middle := length / 2
        left := arr[0:middle]
        right := arr[middle:]
        return merge(mergeSort(left), mergeSort(right))
}

func merge(left []int, right []int) []int {
        var result []int
        for len(left) != 0 && len(right) != 0 {
                if left[0] <= right[0] {
                        result = append(result, left[0])
                        left = left[1:]
                } else {
                        result = append(result, right[0])
                        right = right[1:]
                }
        }

        for len(left) != 0 {
                result = append(result, left[0])
                left = left[1:]
        }

        for len(right) != 0 {
                result = append(result, right[0])
                right = right[1:]
        }

        return result
}

结语

今天的分享到这里就结束啦！如果觉得文章还不错的话，可以三连支持一下。

也可以点点关注，避免以后找不到我哦！

Crossoads主页还有很多有趣的文章，欢迎小伙伴们前去点评，您的支持就是作者前进的动力！

带你初步了解排序算法：https://blog.csdn.net/2301_80191662/article/details/142211265
直接插入排序：https://blog.csdn.net/2301_80191662/article/details/142300973
希尔排序：https://blog.csdn.net/2301_80191662/article/details/142302553
直接选择排序：https://blog.csdn.net/2301_80191662/article/details/142312028
堆排序：https://blog.csdn.net/2301_80191662/article/details/142312338
冒泡排序：https://blog.csdn.net/2301_80191662/article/details/142324131
快速排序：https://blog.csdn.net/2301_80191662/article/details/142324307
归并排序：https://blog.csdn.net/2301_80191662/article/details/142350640
计数排序：https://blog.csdn.net/2301_80191662/article/details/142350741
十大经典排序算法总结与分析：https://blog.csdn.net/2301_80191662/article/details/142211564

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2146534.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Java语言程序设计基础篇_编程练习题*18.28 (非递归目录大小)

Java语言程序设计基础篇_编程练习题*18.28 (非递归目录大小)

目录 题目&#xff1a;*18.28 (非递归目录大小) 习题思路 代码示例 输出结果 题目&#xff1a;*18.28 (非递归目录大小) 不使用递归改写程序清单18-7 习题思路 &#xff08; getSize方法&#xff09; 创建一个变量表示总共的大小。传入路径&#xff0c;创建File文件。创建A…
阅读更多...
Kafka 安全机制详解及配置指南

Kafka 安全机制详解及配置指南

个人名片 &#x1f393;作者简介&#xff1a;java领域优质创作者 &#x1f310;个人主页&#xff1a;码农阿豪 &#x1f4de;工作室&#xff1a;新空间代码工作室&#xff08;提供各种软件服务&#xff09; &#x1f48c;个人邮箱&#xff1a;[2435024119qq.com] &#x1f4f1…
阅读更多...
毕业设计选题：基于ssm+vue+uniapp的面向企事业单位的项目申报小程序

毕业设计选题：基于ssm+vue+uniapp的面向企事业单位的项目申报小程序

开发语言&#xff1a;Java框架&#xff1a;ssmuniappJDK版本&#xff1a;JDK1.8服务器&#xff1a;tomcat7数据库&#xff1a;mysql 5.7&#xff08;一定要5.7版本&#xff09;数据库工具&#xff1a;Navicat11开发软件&#xff1a;eclipse/myeclipse/ideaMaven包&#xff1a;M…
阅读更多...
VisionPro - 基础 - 00 模板匹配技术和在VP中的使用 - PMAlign - PatMax - （2）

VisionPro - 基础 - 00 模板匹配技术和在VP中的使用 - PMAlign - PatMax - （2）

前言&#xff1a; 针对PatMax 的高级应用和原理&#xff0c;在这一节进行说明&#xff1a; PatMax Patterns When you train PatMax you specify a region of interest in an image or provide a description of a shape that includes the features you want to train. If yo…
阅读更多...
一个无聊的网页（无服务器实现网页在线人数统计）

一个无聊的网页（无服务器实现网页在线人数统计）

项目简介 一个无聊且没有任何意义的网页… 无聊的时候打开这个网页&#xff0c;然后可以和这个小黄脸玩趣 &#xff08;当你的鼠标到他面前&#xff0c;他会死死盯住你的鼠标&#xff0c;手机也可以用手指代替鼠标 &#xff09; 你可以看到有多少人和你样无聊 打开方式 sil…
阅读更多...
Centos7-rpm包管理器方式安装MySQL 5.7.25

Centos7-rpm包管理器方式安装MySQL 5.7.25

前言 本文用于学习通过Mysql压缩包在centos7中安装和配置的过程以及过程中碰到的Bug解决。 Mysql安装包下载和上传 MySQL :: Download MySQL Community Server (Archived Versions)https://downloads.mysql.com/archives/community/访问Mysql官方下载站&#xff0c;选择对应的…
阅读更多...
跟《经济学人》学英文：2024年09月14日这期 “The Perfect Couple” and the new map of Moneyland

跟《经济学人》学英文：2024年09月14日这期 “The Perfect Couple” and the new map of Moneyland

“The Perfect Couple” and the new map of Moneyland Depictions of the super-rich on screen reflect the times 原文&#xff1a; FIRST, pick an approachable avatar. In “The Perfect Couple”, a glitzy new drama on Netflix, this role is played by Amelia (Ev…
阅读更多...
【Python】探索 PluginBase：Python 插件系统的灵活构建

【Python】探索 PluginBase：Python 插件系统的灵活构建

我承认这道菜有赌的成分&#xff0c;果然还是赌输了。 在现代软件开发中&#xff0c;插件系统为应用程序提供了极大的灵活性和扩展性。Python&#xff0c;作为一种流行的编程语言&#xff0c;拥有丰富的库和框架来支持插件的开发。今天&#xff0c;我们将深入探讨一个名为Plug…
阅读更多...
股指期货理论价格计算公式是什么？

股指期货理论价格计算公式是什么？

股指期货&#xff0c;作为金融衍生品的一种&#xff0c;其价格与现货市场的股指价格紧密相关&#xff0c;但又受到多种因素的影响。了解股指期货理论价格的计算公式&#xff0c;对于投资者进行套利交易、风险管理等具有重要意义。本文将详细解读股指期货理论价格的计算公式&…
阅读更多...
【Java宝典】——二维数组的寻宝之旅

【Java宝典】——二维数组的寻宝之旅

二维数组 二维数组的创建和打印 数据类型[ ] [ ] 数组名称 new 数据类型[行数][列数]{初始化数据}&#xff1b; import java.util.Arrays;public class DyadicArray {// 二维数组的创建和打印public static void main(String[] args) {// 直接初始化一个二维数组&#xff…
阅读更多...
openssl 生成多域名 多IP 的数字证书

openssl 生成多域名 多IP 的数字证书

openssl.cnf 文件内容&#xff1a; [req] default_bits 2048 distinguished_name req_distinguished_name copy_extensions copy req_extensions req_ext x509_extensions v3_req prompt no [req_distinguished_name] countryName CN stateOrProvinceName GuangDong l…
阅读更多...
Oracle VM VirtualBox仅主机(Host-0nly)网络实现外网连接

Oracle VM VirtualBox仅主机(Host-0nly)网络实现外网连接

目录 1.仅主机(Host-0nly)网络介绍 1.操作步骤 2.测试​编辑 “如果您在解决类似问题时也遇到了困难&#xff0c;希望我的 经验分享 对您有所帮助。如果您有任何疑问或者想分享您的经历&#xff0c;欢迎在评论区留言&#xff0c;我们可以一起探讨解决方案。祝您在编程路上顺利…
阅读更多...
通过多模态关系图学习实现可解释的医学图像视觉问答|文献速递--Transformer架构在医学影像分析中的应用

通过多模态关系图学习实现可解释的医学图像视觉问答|文献速递--Transformer架构在医学影像分析中的应用

Title 题目 Interpretable medical image Visual Question Answering via multi-modal relationship graph learning 通过多模态关系图学习实现可解释的医学图像视觉问答。 01 文献速递介绍 医学视觉问答&#xff08;VQA&#xff09;是医学多模态大语言模型&#xff08;LL…
阅读更多...
通信工程学习：什么是OLT光线路终端

通信工程学习：什么是OLT光线路终端

OLT&#xff1a;光线路终端 OLT&#xff08;Optical Line Terminal&#xff0c;光线路终端&#xff09;是光纤通信系统中的核心局端设备&#xff0c;特别是在无源光网络&#xff08;Passive Optical Network, PON&#xff09;架构中扮演着至关重要的角色。以下是关于OLT光线路终…
阅读更多...
GUI编程15：JPanel、JScroll 面板

GUI编程15：JPanel、JScroll 面板

视频链接&#xff1a;17、文本域JScroll面板_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1DJ411B75F?p17&vd_sourceb5775c3a4ea16a5306db9c7c1c1486b5 1.JPanel package com.yundait.lesson05;import javax.swing.*; import java.awt.*;public class JPanelDem…
阅读更多...
C++速通LeetCode中等第5题-无重复字符的最长字串

C++速通LeetCode中等第5题-无重复字符的最长字串

字串substr法&#xff0c;定义字串的头部和长度&#xff0c;和字串后一位对比&#xff0c;如果不存在重复元素则长度1&#xff0c;存在重复元素则头部更新&#xff0c;长度重置。 class Solution { public:int lengthOfLongestSubstring(string s) {string s2;//存放s的前一部分…
阅读更多...
基于虚拟阻抗的逆变器下垂控制环流抑制策略MATLAB仿真

基于虚拟阻抗的逆变器下垂控制环流抑制策略MATLAB仿真

微❤关注“电气仔推送”获得资料&#xff08;专享优惠&#xff09; 模型简介 由于微电网的弱电网特性&#xff0c;变流器并网线路较大的阻感比会导致变流器输出功率不能近似解耦&#xff0c;从而影响其下垂控制的精度。另外变流器并网线路阻抗的不确定性还会导致变流器之间分…
阅读更多...
放过自己，决绝内耗

放过自己，决绝内耗

其实真正折磨你的&#xff0c;从来不是任何人的绝情&#xff0c;也不是糟糕的事情&#xff0c;而是你心存幻想的期待和无法控制的想象力&#xff0c;很多时候&#xff0c;你不是过不去生活的那道坎&#xff0c;而是过不了你心里的那一关&#xff0c;世间万物都在治愈你&#xf…
阅读更多...
深入探究 Flask 的应用和请求上下文

深入探究 Flask 的应用和请求上下文

目标 读完本文后&#xff0c;您应该能够解释&#xff1a; 什么是上下文哪些数据同时存储在应用程序和请求上下文中在 Flask 中处理请求时&#xff0c;处理应用程序和请求上下文所需的步骤如何使用应用程序和请求上下文的代理如何在视图函数中使用current_app和代理request什么…
阅读更多...
『功能项目』第三职业弓弩的平A【58】

『功能项目』第三职业弓弩的平A【58】

我们打开上一篇57第二职业法师的平A的项目&#xff0c; 本章要做的事情是实现第三职业弓弩的平A伤害 首先修改脚本&#xff1a;MagicBall.cs 将脚本挂载在Sphere预制体身上 注意组件设置 运行项目 本章做了第三职业弓弩的平A伤害及显示伤害UI 接下来文章的内容&#xff1a; …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023