排序算法之归并排序

最新推荐文章于 2022-11-02 10:51:13 发布
最新推荐文章于 2022-11-02 10:51:13 发布
阅读量167 收藏
点赞数
分类专栏： 学习笔记 数据结构与算法 文章标签： 数据结构 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46600354/article/details/105811357
版权

归并排序以O(N log N)最坏情形时间运行, 所使用的比较次数几乎是最优的
该算法是采用分治的思想实现, 将数组依次对半拆分, 排好序后再逐一合并
由于需要另外的一个数组来保存临时排好序的数据, 所以在空间上存在一些损耗

分治思想

分的过程将问题分成一些小的问题然后递归求解，而治的阶段则将分的阶段得到的各答案拼接在一起
在这里插入图片描述
图片来自: https://www.cnblogs.com/chengxiao/p/6194356.html

代码实现

public class MergeSort {
	/*
		提供给外部的方法
		注意: 本方法可对任意的引用类型排序, 
			但需对该类型实现Comparable接口, 排序中的大小比较是通过Comparable#CompareTo方法实现
			基本类型int等, 通过转换成包装类Integer即可使用
	*/
    public static <AnyType extends Comparable<? super AnyType>> void mergeSort(AnyType[] arr) {
        AnyType[] tmpArr = (AnyType[]) new Comparable[arr.length];
        mergeSort(arr, tmpArr, 0, arr.length - 1);
    }

	/*
		将数组进行拆分, 形成类似完全二叉树的结构
	*/
    private static <AnyType extends Comparable<? super AnyType>> void mergeSort(AnyType[] arr, AnyType[] tmpArr, int left, int right) {
        if (left < right) {
        	//每次对半找出中间点
            int center = (left + right) / 2;
            //分的过程
            mergeSort(arr, tmpArr, left, center);	//向左递归对折
            mergeSort(arr, tmpArr, center + 1, right);	//向右递归对折
            //治的过程, 将拆分后的树形结构, 从左往右, 从下往上逐层排序
            merge(arr, tmpArr, left, center + 1, right);
        }
    }

	/*
		通过一个临时数组, 将左右两段中的数据有序的填充到临时数组中, 就能轻松地实现排序的过程, 再将临时数组中的数据恢复到原数组即可
	*/
    private static <AnyType extends Comparable<? super AnyType>> void merge(AnyType[] arr, AnyType[] tmpArr,
                                                                           int leftPos, int rightPos, int rightEnd) {
        int leftEnd = rightPos - 1;
        int tmpPos = leftPos;
        int length = rightEnd - leftPos + 1;

        //将左右两段中, 最小的数据依次填充到临时数组中
        while (leftPos <= leftEnd && rightPos <= rightEnd) {
            if (arr[leftPos].compareTo(arr[rightPos]) <= 0)
                tmpArr[tmpPos++] = arr[leftPos++];
            else
                tmpArr[tmpPos++] = arr[rightPos++];
        }

        //若左段数组中还有数据, 将剩余部分直接填充到临时数组中
        while (leftPos <= leftEnd)
            tmpArr[tmpPos++] = arr[leftPos++];

        //若右段数组中还有数据, 将剩余部分直接填充到临时数组中
        while (rightPos <= rightEnd)
            tmpArr[tmpPos++] = arr[rightPos++];

        //将数据从临时数组中转存到原数组
        for (int i = 0; i < length; i++, rightEnd--) {	
            arr[rightEnd] = tmpArr[rightEnd];
        }
    }
}

排序的中间过程结果(merge方法中)

以3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48序列为例
排序前: [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
tmpArr:[3, 44, null, null, null, null, null, null, null, null, null, null, null, null, null]
arr:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
length:2
tmpArr:[3, 44, 5, 38, null, null, null, null, null, null, null, null, null, null, null]
arr:[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
length:2
tmpArr:[3, 5, 38, 44, null, null, null, null, null, null, null, null, null, null, null]
arr:[3, 44, 5, 38, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
length:4
tmpArr:[3, 5, 38, 44, 15, 47, null, null, null, null, null, null, null, null, null]
arr:[3, 5, 38, 44, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
length:2
tmpArr:[3, 5, 38, 44, 15, 47, 26, 36, null, null, null, null, null, null, null]
arr:[3, 5, 38, 44, 15, 47, 36, 26, 27, 2, 46, 4, 19, 50, 48]
length:2
tmpArr:[3, 5, 38, 44, 15, 26, 36, 47, null, null, null, null, null, null, null]
arr:[3, 5, 38, 44, 15, 47, 26, 36, 27, 2, 46, 4, 19, 50, 48]
length:4
tmpArr:[3, 5, 15, 26, 36, 38, 44, 47, null, null, null, null, null, null, null]
arr:[3, 5, 38, 44, 15, 26, 36, 47, 27, 2, 46, 4, 19, 50, 48]
length:8
tmpArr:[3, 5, 15, 26, 36, 38, 44, 47, 2, 27, null, null, null, null, null]
arr:[3, 5, 15, 26, 36, 38, 44, 47, 27, 2, 46, 4, 19, 50, 48]
length:2
tmpArr:[3, 5, 15, 26, 36, 38, 44, 47, 2, 27, 4, 46, null, null, null]
arr:[3, 5, 15, 26, 36, 38, 44, 47, 2, 27, 46, 4, 19, 50, 48]
length:2
tmpArr:[3, 5, 15, 26, 36, 38, 44, 47, 2, 4, 27, 46, null, null, null]
arr:[3, 5, 15, 26, 36, 38, 44, 47, 2, 27, 4, 46, 19, 50, 48]
length:4
tmpArr:[3, 5, 15, 26, 36, 38, 44, 47, 2, 4, 27, 46, 19, 50, null]
arr:[3, 5, 15, 26, 36, 38, 44, 47, 2, 4, 27, 46, 19, 50, 48]
length:2
tmpArr:[3, 5, 15, 26, 36, 38, 44, 47, 2, 4, 27, 46, 19, 48, 50]
arr:[3, 5, 15, 26, 36, 38, 44, 47, 2, 4, 27, 46, 19, 50, 48]
length:3
tmpArr:[3, 5, 15, 26, 36, 38, 44, 47, 2, 4, 19, 27, 46, 48, 50]
arr:[3, 5, 15, 26, 36, 38, 44, 47, 2, 4, 27, 46, 19, 48, 50]
length:7
tmpArr:[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
arr:[3, 5, 15, 26, 36, 38, 44, 47, 2, 4, 19, 27, 46, 48, 50]
length:15
排序后: [2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

动图效果
在这里插入图片描述

啄木鸟也会飞
关注
专栏目录
排序算法：归并排序
程序员囧辉
06-07 2917
前言 这篇文章本该发表于2018年4月份末，在排序算法：快速排序之后，但是不知道什么原因，这篇文章忘了在CSDN上发表，今天在看博客的时候突然发现，因此补上。 概述 之前介绍过排序算法中效率很高的“快速排序”。本文将介绍另一个高效的排序算法——“归并排序”。 基本思想 归并排序的主要思想是分治法。主要过程是： 将n个元素从中间切开，分成两部分。（左边可能比右边多1个...
归并排序
xuguoli_beyondboy的专栏
11-14 1452
在归并排序的迭代算法中，可以把输入序列看成是个n个已排序序列，其中每个序列的长度为1，将这些序列两两归并就得到了 n/2个长度为2的序列（如果n为奇数，则有一个序列长度为1），然后对这n/2这个序列进行两两归并，依次类推，直到只剩下一个序列为止。 归并排序是在输入记录上执行若干遍归并，其中第一遍归并的是长度为1的子序列，第二遍归并的是长度为2的子序列，而第i遍归并的是长度为2i−12^{i-1}
请你使用归并排序对这个数列按照从小到大进行排序。
a599s的博客
07-12 1645
请你使用归并排序对这个数列按照从小到大进行排序。 并将排好序的数列按顺序输出。 输入格式 输入共两行，第一行包含整数 n。 第二行包含 n 个整数（所有整数均在1~109范围内），表示整个数列。 输出格式 输出共一行，包含 n 个整数，表示排好序的数列。 数据范围 1≤n≤100000 #include<stdio.h> #include<stdio.h> void merge(int num1[],int num2[],int start,int mid,int end )//进
C#排序算法之归并排序
12-20
归并排序是一种高效的排序算法，属于分治策略的典型应用。在C#中，我们可以用递归的方式来实现归并排序。归并排序的基本思想是将待排序的元素序列分为两个子序列，分别对这两个子序列进行排序，然后将排好序的子序列...
C语言实现排序算法之归并排序详解
12-25
排序算法中的归并排序(Merge Sort)是利用”归并”技术来进行排序。归并是指将若干个已排序的子文件合并成一个有序的文件。 一、实现原理： 1、算法基本思路 设两个有序的子文件(相当于输入堆)放在同一向量中相邻的...
java数据结构排序算法之归并排序详解
08-30
Java数据结构排序算法之归并排序是基于合并的思想，将两个或两个以上有序表合并成一个新的有序表。这种方法被称作是2-路归并排序（基本操作是将待排序列中相邻的两个有序子序列合并成一个有序序列）。 归并排序的...
C++排序算法之归并排序源码
06-29
### C++排序算法之归并排序源码解析 #### 归并排序简介 归并排序是一种高效的、基于分治策略的排序算法。它利用了分而治之的思想，通过递归地将数组分成越来越小的部分，然后将这些部分重新合并为更大的、已排序的...
三月十一日
sheep_princess的博客
03-11 221
1.5h 高等数学网课 1h 完成高等数学课后作业以及英语视听说课后作业 今天的高等数学作业相对来说比之前简单，然而英语不行的我就要在听写上花费更多时间以完成作业。 2h 学习数据结构 排序 稳定性 假设k1=kj;(1<=i<=n,1<=j<=n),且在排序前的序列中ri领先于rj（i<j），如果排序后ri仍领先于rj，则称为该排序方法稳定，否则为不稳定。 内排序与...
归并排序基本操作
qq_43573743的博客
12-30 214
#include <bits/stdc++.h> using namespace std; class Sort { public: Sort(int a[],int n); //两个相邻子序列的合并 void MergeSort(int first,int last); void pp() { for(int i=0;...
归并排序心得
zealPeak的博客
04-09 645
/归并排序 /* 主要利用了递归的思想 先利用mid中间数将数组拆分成单个 在依次两两结合 结合的过程中对数组元素进行比较并且排序 递归完毕之后 排序也结束*/ public class MergeSort { public static void merge(int[] a,int left,int mid,int right){ int[] temp = new...
【数据结构笔记45】通过中间步骤区分简单插入排序和归并排序
记录学习痕迹的公众号：Piper蛋窝
10-23 491
这道题要考察对插入排序和归并排序（非递归）的性质的理解和过程的熟悉程度。
排序算法-归并排序详细讲解（MergeSort）
热门推荐
GTW、Zeus的博客
07-11 1万+
归并，指合并，合在一起。归并排序（Merge Sort）是建立在归并操作上的一种排序算法。其主要思想是分而治之。若将两个有序集合并成一个有序表，称为2-路归并，与之对应的还有多路归并。借助一个辅助空数组，把左右两边的数组按照大小比较，按顺序放入辅助数组中即可。以下面两个有序数组为例： public static void mergeSort(int[] arr){ if (arr == null || arr.length<2){ return;
一文详解归并排序
abc123mma的博客
11-02 562
归并排序
【0基础学算法】归并排序(超详细讲解+私人笔记+源码）
感谢您的关注！
08-23 1393
归并排序是一个稳定的排序算法，在进行子数组合并的时候，我们可以设置当元素大小相等时，先将前半部分的数据放入临时数组，这样就可以保证相等元素在排序后依然保持原来的顺序，并且归并排序的执行效率与原始数据的有序程度无关，其时间复杂度是非常稳定的，都是O(nlogn) 。......
归并排序 图解算法过程
冰冻火山
12-26 1万+
归并排序，图解，详细过程。时间增长度，O(N*lgN)，对于每一层，是将2个有序数组合并成一个有序数组，时间复杂度为O(N)，一共lgN层。代码如下：package com.collonn.algorithm.sort; /** * &lt;pre&gt; * 经典归并排序 * &lt;/pre&gt; */ public class MergeSort { public void ...
快速排序（输出中间过程）
weixin_30810239的博客
03-08 1689
1: #include <cstdio> 2: #include <algorithm> 3: using namespace std; 4: const int maxn=10000; 5: int a[maxn],n; 6: 7: int Partition(int l,...
二分归并排序算法_排序算法之归并排序
最新发布
05-24
归并排序（Merge Sort）是一种稳定的、基于比较的排序算法，最坏时间复杂度为 O(nlogn)。其基本思想是将待排序序列分成若干个子序列，每个子序列都是有序的，然后将子序列合并成整体有序的序列。 归并排序的实现方法有两种：自顶向下和自底向上。 自顶向下的归并排序算法实现： 1. 将待排序序列分成两个子序列，分别对这两个子序列进行递归排序。 2. 将两个已经排好序的子序列合并为一个有序序列。 自底向上的归并排序算法实现： 1. 将待排序序列每个元素看成一个独立的有序序列，进行两两合并。 2. 得到 n/2 个长度为 2 的有序序列，再两两合并。 3. 重复步骤 2，直到得到一个长度为 n 的有序序列。 下面是自顶向下的归并排序算法的实现代码（使用了递归）: ``` void MergeSort(int arr[], int left, int right) { if (left >= right) return; int mid = left + (right - left) / 2; MergeSort(arr, left, mid); MergeSort(arr, mid + 1, right); int* temp = new int[right - left + 1]; int i = left, j = mid + 1, k = 0; while (i <= mid && j <= right) { if (arr[i] <= arr[j]) temp[k++] = arr[i++]; else temp[k++] = arr[j++]; } while (i <= mid) temp[k++] = arr[i++]; while (j <= right) temp[k++] = arr[j++]; for (int p = 0; p < k; p++) arr[left + p] = temp[p]; delete[] temp; } ``` 下面是自底向上的归并排序算法的实现代码（使用了迭代）： ``` void MergeSort(int arr[], int n) { int* temp = new int[n]; for (int len = 1; len < n; len *= 2) { for (int left = 0; left < n - len; left += len * 2) { int mid = left + len - 1; int right = min(left + len * 2 - 1, n - 1); int i = left, j = mid + 1, k = 0; while (i <= mid && j <= right) { if (arr[i] <= arr[j]) temp[k++] = arr[i++]; else temp[k++] = arr[j++]; } while (i <= mid) temp[k++] = arr[i++]; while (j <= right) temp[k++] = arr[j++]; for (int p = 0; p < k; p++) arr[left + p] = temp[p]; } } delete[] temp; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值