java数据结构和算法——归并排序算法

最新推荐文章于 2023-04-07 22:10:47 发布
最新推荐文章于 2023-04-07 22:10:47 发布
阅读量322 收藏 1
点赞数
分类专栏： java数据结构和算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li1325169021/article/details/107924368
版权

目录

一、归并排序介绍

  • 归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

二、归并排序算法的思路分析图

在这里插入图片描述在这里插入图片描述

三、归并排序算法的应用示例需求

arr={8,4,5,7,1,3,6,2},请使用归并排序完成数组的排序。

四、归并排序算法的示例

1、代码

package com.rf.springboot01.dataStructure.sort;

import java.util.Arrays;

/**
 * @description: 归并排序示例
 * @author: xiaozhi
 * @create: 2020-08-11 21:11
 */
public class MergeSort {
    public static void main(String[] args) {
        int[] arr={ 8, 4, 5, 7, 1, 3, 6, 2};
        int[] temp =new int[arr.length];//递归需要一个额外的临时中转数组
        splitMerge(arr,0,arr.length-1,temp);
        System.out.println("归并排序后的数组："+Arrays.toString(arr));
    }
    /** 
    * @Description: 分解+合并方法
    * @Param:  arr 排序的原始数组
     *          left  左边初始索引
     *          right 右边末尾索引
     *          temp 临时的中转数组
    * @Author: xz  
    * @return: 
    * @Date: 2020/8/11 22:54  
    */
    public static void  splitMerge(int[] arr, int left,int right,int[] temp){
        if(left < right){// 左边初始索引 < 右边末尾索引
            int mid=(left+right)/2;//中间索引
            //向左递归进行分解
            splitMerge(arr,left,mid,temp);
            //向右递归进行分解
            splitMerge(arr,mid+1,right,temp);
            //合并
            merge(arr,left,mid,right,temp);
        }
    }
    /** 
    * @Description: 合并的方法
    * @Param: arr 排序的原始数组
     *         left 左边有序序列的初始索引
     *         middle 中间索引
     *         right 右边索引
     *         temp  临时的中转数组
    * @Author: xz  
    * @return: void
    * @Date: 2020/8/11 21:30  
    */ 
    public static  void merge(int[] arr,int left,int middle,int right,int[] temp){

        int i=left;//初始化i作为左边有序序列的初始索引
        int j=middle+1;//初始化j作为右边有序序列的初始索引
        int t=0;//指向临时的中转数组的当前索引

        /**
        *  一、
        *   1、先把左右两边有序的数据按照规则填充到temp数组
        *   2、直到左右两边有序序列有一遍处理完毕
        */
        //当左边有序序列的初始索引 <= 中间索引  &&  右边有序序列的初始索引 <= 右边索引
        while(i <=middle && j <=right){
            if(arr[i] <= arr[j]){//左边的有序序列的当前元素 <= 右边有序序列的当前元素
                temp[t]=arr[i];//将左边有序序列的当前元素拷贝到中转数组temp中
                t+=1;//中转数组temp的下标+1，即后移
                i+=1;//左边有序序列数组下标+1，即后移
            }else{ //否则，左边的有序序列的当前元素 >= 右边有序序列的当前元素
               temp[t]=arr[j];//将右边有序序列的当前元素拷贝到中转数组temp中
               t+=1;//中转数组temp的下标+1，即后移
               j+=1;//右边有序序列数组下标+1，即后移
            }
        }
        /**
         * 二、把剩余数据的一遍的数据一次全部填充到temp数组
         */
        while(i <= middle){//当左边有序序列的初始索引 <= 中间索引
            temp[t]=arr[i];//左边的有序序列还有剩余的元素，就全部填充到temp
            t+=1;//中转数组temp的下标+1，即后移
            i+=1;//左边有序序列数组下标+1，即后移
        }
        while(j <= right){//当右边有序序列的初始索引 <= 右边索引
            temp[t]=arr[j];//右边的有序序列还有剩余的元素，就全部填充到temp
            t+=1;//中转数组temp的下标+1，即后移
            j+=1;//右边有序序列数组下标+1，即后移
        }
        /**
         * 三、将temp数组的袁术拷贝到arr原始数组中
         *     注意，并不是每次都拷贝所有数据
         */
        t=0;
        int tempLeft=left;
        while(tempLeft <= right){
            arr[tempLeft] =temp[t];
            t+=1;
            tempLeft+=1;
        }
    }
}

2、运行main函数，运行结果如下：
在这里插入图片描述

五、测试归并排序算法一千万条数据所消耗的时间示例

1、代码

package com.rf.springboot01.dataStructure.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

/**
 * @description:
 * @author: xiaozhi
 * @create: 2020-08-11 23:35
 */
public class MergeSort2 {
    public static void main(String[] args) {
        int arr[] = new int[10000000];
        for(int i=0;i<10000000;i++){//创建一个带有10000000个随机数的数组
            arr[i]= (int) (Math.random()*8000000); //随机生成（0到8000000之间）的数
        }
        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(data1);
        System.out.println("归并排序前的时间是=" + date1Str);

        int[] temp =new int[arr.length];//递归需要一个额外的临时中转数组
        splitMerge(arr,0,arr.length-1,temp);

        Date data2 = new Date();
        String date2Str = simpleDateFormat.format(data2);
        System.out.println("归并排序后的时间是=" + date2Str);

    }
    /**
     * @Description: 分解+合并方法
     * @Param:  arr 排序的原始数组
     *          left  左边初始索引
     *          right 右边末尾索引
     *          temp 临时的中转索引
     * @Author: xz
     * @return:
     * @Date: 2020/8/11 22:54
     */
    public static void  splitMerge(int[] arr, int left,int right,int[] temp){
        if(left < right){// 左边初始索引 < 右边末尾索引
            int mid=(left+right)/2;//中间索引
            //向左递归进行分解
            splitMerge(arr,left,mid,temp);
            //向右递归进行分解
            splitMerge(arr,mid+1,right,temp);
            //合并
            merge(arr,left,mid,right,temp);
        }
    }
    /**
     * @Description: 合并的方法
     * @Param: arr 排序的原始数组
     *         left 左边有序序列的初始索引
     *         middle 中间索引
     *         right 右边索引
     *         temp  临时的中转数组
     * @Author: xz
     * @return: void
     * @Date: 2020/8/11 21:30
     */
    public static  void merge(int[] arr,int left,int middle,int right,int[] temp){

        int i=left;//初始化i作为左边有序序列的初始索引
        int j=middle+1;//初始化j作为右边有序序列的初始索引
        int t=0;//指向临时的中转数组的当前索引

        /**
         *  一、
         *   1、先把左右两边有序的数据按照规则填充到temp数组
         *   2、直到左右两边有序序列有一遍处理完毕
         */
        //当左边有序序列的初始索引 <= 中间索引  &&  右边有序序列的初始索引 <= 右边索引
        while(i <=middle && j <=right){
            if(arr[i] <= arr[j]){//左边的有序序列的当前元素 <= 右边有序序列的当前元素
                temp[t]=arr[i];//将左边有序序列的当前元素拷贝到中转数组temp中
                t+=1;//中转数组temp的下标+1，即后移
                i+=1;//左边有序序列数组下标+1，即后移
            }else{ //否则，左边的有序序列的当前元素 >= 右边有序序列的当前元素
                temp[t]=arr[j];//将右边有序序列的当前元素拷贝到中转数组temp中
                t+=1;//中转数组temp的下标+1，即后移
                j+=1;//右边有序序列数组下标+1，即后移
            }
        }
        /**
         * 二、把剩余数据的一遍的数据一次全部填充到temp数组
         */
        while(i <= middle){//当左边有序序列的初始索引 <= 中间索引
            temp[t]=arr[i];//左边的有序序列还有剩余的元素，就全部填充到temp
            t+=1;//中转数组temp的下标+1，即后移
            i+=1;//左边有序序列数组下标+1，即后移
        }
        while(j <= right){//当右边有序序列的初始索引 <= 右边索引
            temp[t]=arr[j];//右边的有序序列还有剩余的元素，就全部填充到temp
            t+=1;//中转数组temp的下标+1，即后移
            j+=1;//右边有序序列数组下标+1，即后移
        }
        /**
         * 三、将temp数组的袁术拷贝到arr原始数组中
         *     注意，并不是每次都拷贝所有数据
         */
        t=0;
        int tempLeft=left;
        while(tempLeft <= right){
            arr[tempLeft] =temp[t];
            t+=1;
            tempLeft+=1;
        }
    }
}

2、运行main函数，运行结果如下：
在这里插入图片描述在这里插入图片描述

本地计算机，win10系统，8G内存测试带有一千万个随机数的数组，用归并排序耗时大约2秒

小志的博客
关注
专栏目录
java 实现归并排序算法
h624536203的博客
07-09 272
归并排序算法的核心思想是要将两个有序数组归并为一个有序数组，再归并排序的初始时，是对两个分别有一个元素的数组（一个元素显然是有序的）进行归并 下边是时实现这个核心思想的java代码 // 在下边的方法中 其实是对 /** * * @param a 源数据 * @param b 目标数据 * @param i 数据块1的起始索引 * @param s 数据块2的起始索引 也是数据块1的结束索引+1 * @param h 数据块2的结束索引 */ private static void
排序算法——归并排序
心皿月的博客
07-16 4697
目录： 🍉算法思想 🥝算法描述 🍒实例 具体步骤： 代码实现： 🍍算法效率分析。 归并排序（Mergesort）是建立在归并的有效操作上进行排序，主要采用分治法将已有序的子序列合并，得到完全有序的序列。即先让每一小段有序，再让小段之间变得有序。将两个有序段归并为一个有序段，称为二路归并；有序段称为归并段。分治法将一个大问题成一些小的问题然后递归求解，而的阶段则将分的阶段得到的各答案“修补”在一起，即分而治之。如下图所示。......
java归并排序算法
05-04 4233
归并排序的时间复杂度是：nlogn主要是用到二路归并排序，也就是把两个有序集合合并为一个有序集合。下面是我写的一个递归二路归并排序的算法：package algorithm;public class MergeSort { // private static long sum = 0; /** * * 二路归并 * 原理：将两个有序表合并和一个有
Java 归并排序算法
weixin_30876945的博客
12-13 47
/** * * 改进后的归并排序: * */ public class ImprovedMergeSort { private static final int THRESHOLD = 10; public void sort(int[] data) { int[] temp = new int[data.length]; ...
归并排序
beemo的博客
07-25 120
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 先分割，再合并。 排序过程： 1.申请大小为两个已经排序完毕的序列之和的空间，用来存放合并之后的序列。 2.设定两个...
数据结构与算法——归并排序: 数组&链表&递归&非递归解法全家桶
Heriam的博客
12-19 365
原文链接：https://jiang-hao.com/articles/2020/algorithms-algorithms-merge-sort.html 文章目录算法介绍算法步骤代码实现数组实现时间复杂度O(NlogN)，空间复杂度O(N)递归实现一：每次归并时都创建一个辅助数组递归实现二：仅创建一次一个等长的辅助数组，交替归并非递归实现链表实现时间复杂度O(NlogN)，空间复杂度O(1)递归实现非递归实现(从底至顶直接合并)算法复杂度 算法介绍 归并排序（Merge sort）是建立在归并操作上.
java中的排序算法——归并排序
lx_Frolf的博客
09-03 457
归并排序 归并是将两个或两个以上的有序表合并成一个新的有序表，可分为多路归并排序、两路归并排序，可用于内排序，也可用于外排序。 原理：先将长度为n的一个有序列表以n/2的长度进行递归分割，直到分割为n个有序列表，每个有序列表的长度为1，再进行两两归并，得到n/2个长度为2的有序列表，进行递归合并后归并成一个长度为n的有序列表。 Java实现的二路归并排序算法代码实现如下： 输出...
Java数据结构——归并排序
NoBug
03-04 630
1. 归并排序**************** 2. 复制截取数组函数****** 3. 归并函数**************** 4. 迭代*********************
数据结构&算法——Java.zip
最新发布
01-14
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
Java归并排序算法
weixin_44256581的博客
07-19 89
package com.tentact.sort; import java.text.SimpleDateFormat; import java.util.Arrays; import java.util.Date; public class MergetSort { public static void main(String[] args) { int arr[] = { 8, 4, 5, 7, 1, 3, 6, 2 }; // //测试快排的执行速度 // 创建要给80000
归并排序算法（java实现）
qq_45954420的博客
03-10 1万+
基本思想 归并排序是由递归实现的，主要是分而治之的思想，也就是通过将问题分解成多个容易求解的局部性小问题来解开原本的问题的技巧。 归并排序在合并两个已排序数组时，如果遇到了相同的元素，只要保证前半部分数组优先于后半部分数组， 相同元素的顺序就不会颠倒。所以归并排序属于稳定的排序算法。 每次分别排左半边和右半边，不断递归调用自己，直到只有一个元素递归结束，开始回溯，调用 merge 函数，合并两个有序序列，再合并的时候每次给末尾追上一个最大 int 这样就不怕最后一位的数字不会被排序。 归并排序的效率
java的归并排序算法_java归并排序算法
weixin_33573700的博客
02-21 179
/*** 归并排序：里面是一个递归程序，深刻理解之。*/public class MergeSort {/*** 递归划分数组** @param arr* @param from* @param end* @param c* void*/public void partition(Integer[] arr, int from, int end) {// 划分到数组只有一个元...
Java之归并排序算法(一)
jlnwan的专栏
01-29 298
public class MergeSort { public static void mergeSort(int[] list) { if(list.length>1) { int[] firstHalf = new int[list.length/2]; System.arraycopy(list, 0, firstHalf, 0, list.length/2); m
用java实现归并排序算法
热门推荐
Mark的博客
05-10 1万+
用java实现归并排序 一. 归并排序的思路 归并排序通过不断的将原数组进行拆分(通常拆分成左右两项)，一直到剩下一项，然后分别将拆分的子数组进行合并，此时，两个子数组已经是排好序的，所以合并排序只需要进行一趟排序即可完成，所以此类排序需要两个步骤：1.拆分原数组 2.合并子数组。因此此算法是经典的分治算法。 拆分算法的思路 利用递归，不断得寻找左子数组和右子数组，一直到数组的长度为一 合并算法的...
java实现归并排序算法
wangzhen的博客
03-13 5043
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并操作的工作原理如下： 第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列 第二步：设定
Java排序算法：归并排序
jt781861965的博客
05-20 153
归并排序（Merge Sort） 动图演示地址（https://www.cs.usfca.edu/~galles/visualization/ComparisonSort.html） 代码结构 源码 前置条件：父接口和测试类从上篇文章获取（https://blog.csdn.net/jt781861965/article/details/117051443） package suanfa.paixu; public class GuiBingTest implements Sort {
java排序算法：归并排序
mr557的博客
04-07 194
java排序算法：归并排序
Java实现排序算法详解：快速排序与归并排序
以下将详细解释Java实现的这两种经典排序算法——快速排序和归并排序。 1. **快速排序（Quick Sort）**： 快速排序是一种高效的分治算法，由C.A.R. Hoare在1960年提出。它的基本思想是选取一个基准值（pivot），将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小志的博客

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值