归并排序

最新推荐文章于 2024-07-25 06:53:26 发布
最新推荐文章于 2024-07-25 06:53:26 发布
阅读量158 收藏
点赞数
分类专栏： 算法 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42745404/article/details/108193932
版权

归并排序：两个有序的数组合并成一个数组，指针I为第一个数组的开头，指针J为第二个数组的开头，比较两个元素，选择相对小的元素放入到合并空间，并移动指针到下一个

分成两个数组，两个数组都是有序的

在这里插入图片描述
比较大小2>1,1移到新数组里面，J指针往后一格
在这里插入图片描述
比较大小3>2,2移到新数组里面，I指针往后一格
在这里插入图片描述
比较大小4>3,3移到新数组里面，J指针往后一格
在这里插入图片描述
比较大小9>4,4移到新数组里面，I指针往后一格
在这里插入图片描述
比较大小9>5,5移到新数组里面
在这里插入图片描述
只剩下数字9，放上去
在这里插入图片描述
一般情况下，数组都不是有序的，因此程序一般有递归把数组分到最小，然后用上面两个有序数组合并到一个数组。
如：
在这里插入图片描述
现在从下往上，从每个小数组里排序合并数组排序(新数组)(从下往上看)
在这里插入图片描述

代码

假如两个数组是有序的
245 139

package com.my;

public class MergeSort {

    public static void main(String[] args) {
        int[] ints1= new int[]{2,4,5};
        int[] ints2= new int[]{1,3,9};

        //合并成新数组
        int[] newInts = new int[ints1.length+ints2.length];
        int i=0,j=0;
        int p=0;
        //第一想的，如图上第一第二张
        //比较大小2>1,1移到新数组里面，J指针往后一格
        if(ints1[i]>ints2[j]){
            newInts[p++]= ints2[0];
            j++;
        }else{
            newInts[p++]= ints1[0];
            i++;
        }
        print(newInts);
    }

    public static void print(int[] ints){
        for(int i:ints){
            System.out.print(i);
        }
    }
}


100000

2放上去，继续走

package com.my;

public class MergeSort {

    public static void main(String[] args) {
        int[] ints1= new int[]{2,4,5};
        int[] ints2= new int[]{1,3,9};

        //合并成新数组
        int[] newInts = new int[ints1.length+ints2.length];
        int i=0,j=0;
        int p=0;
        //第一想的，如图上第一第二张
        //比较大小2>1,1移到新数组里面，J指针往后一格
        if(ints1[i]>ints2[j]){
            newInts[p++]= ints2[0];
            j++;
        }else{
            newInts[p++]= ints1[0];
            i++;
        }

        //2放上去
        if(ints1[i]>ints2[j]){
            newInts[p++]= ints2[0];
            j++;
        }else{
            newInts[p++]= ints1[0];
            i++;
        }
        print(newInts);
    }

    public static void print(int[] ints){
        for(int i:ints){
            System.out.print(i);
        }
    }
}


120000

合并代码块

if(ints1[i]>ints2[j]){
            newInts[p++]= ints2[0];
            j++;
        }else{
            newInts[p++]= ints1[0];
            i++;
        }

合并后

package com.my;

public class MergeSort {

    public static void main(String[] args) {
        int[] ints1= new int[]{2,4,5};
        int[] ints2= new int[]{1,3,9};

        //合并成新数组
        int[] newInts = new int[ints1.length+ints2.length];
        int i=0,j=0;
        int p=0;
        //第一想的，如图上第一第二张
        //比较大小2>1,1移到新数组里面，J指针往后一格
        while(i<ints1.length && j<ints2.length){
            if(ints1[i]>ints2[j]){
                newInts[p++]= ints2[j];
                j++;
            }else{
                newInts[p++]= ints1[i];
                i++;
            }
        }
        print(newInts);

    }

    public static void print(int[] ints){
        for(int i:ints){
            System.out.print(i);
        }
    }

}


123450

修改判断值(临界值)，或者添加

package com.my;

public class MergeSort {

    public static void main(String[] args) {
        int[] ints1= new int[]{2,4,5};
        int[] ints2= new int[]{1,3,9};

        //合并成新数组
        int[] newInts = new int[ints1.length+ints2.length];
        int i=0,j=0;
        int p=0;
        //第一想的，如图上第一第二张
        //比较大小2>1,1移到新数组里面，J指针往后一格
        while(i<ints1.length && j<ints2.length){
            if(ints1[i]>ints2[j]){
                newInts[p++]= ints2[j];
                j++;
            }else{
                newInts[p++]= ints1[i];
                i++;
            }
        }
        //添加最后值
        //添加最后值
        while(i<=ints1.length-1){
            newInts[i]=ints1[i];
            i++;
        }
        while(j<=ints2.length-1){
            newInts[p]=ints2[j];
            j++;
        }

        print(newInts);

    }

    public static void print(int[] ints){
        for(int i:ints){
            System.out.print(i);
        }
    }

}


123459

上面是两个有序数组的思维，一般情况下我们针对一个无序数组去排序，先展示下一个无序数组，分开后是有序的，
{1,4,7,8,3,6,9}分成两个后，代码上的指针也要对应的改
1278
369

package com.my;

public class MergeSort {

    public static void main(String[] args) {
        int[] ints1= new int[]{1,4,7,8,3,6,9};

        int[] merge = merge(ints1);
        print(merge);

    }


    private static int[] merge(int[] ints1) {
        int[] newInts = new int[ints1.length];
        int mid = newInts.length/2;
        int i=0,j=mid+1;
        int p=0;
        //第一想的，如图上第一第二张
        while(i<mid && j<ints1.length){
            if(ints1[i]>=ints1[j]){
                newInts[p++]= ints1[j];
                j++;
            }else{
                newInts[p++]= ints1[i];
                i++;
            }
        }
        //i指针往右剩下的
        while(i<=mid){
            newInts[p++]=ints1[i];
            i++;
        }
        //j指针往右剩下的
        while(j<=ints1.length-1){
            newInts[p]=ints1[j];
            j++;
        }
        return newInts;
    }

    public static void print(int[] ints){
        for(int i:ints){
            System.out.print(i);
        }
    }

}


1346789

代码优化 其实j++,i++可以写在判断里面

package com.my;

public class MergeSort {

    public static void main(String[] args) {
        int[] ints1= new int[]{1,4,7,8,3,6,9};

        int[] merge = merge(ints1);

        print(merge);

    }


    private static int[] merge(int[] ints1) {
        int[] newInts = new int[ints1.length];
        int mid = newInts.length/2;
        int i=0,j=mid+1;
        int p=0;
        //第一想的，如图上第一第二张
        while(i<mid && j<ints1.length){
            if(ints1[i]>=ints1[j]){
                newInts[p++]= ints1[j++];
            }else{
                newInts[p++]= ints1[i++];
            }
        }
        //添加最后值
        while(i<=mid){
            newInts[p++]=ints1[i++];
        }
        while(j<=ints1.length-1){
            newInts[p]=ints1[j++];
        }
        return newInts;
    }

    public static void print(int[] ints){
        for(int i:ints){
            System.out.print(i);
        }
    }

}

针对if else 只有两个判断条件时，改成三目运算符

package com.my;

public class MergeSort {

    public static void main(String[] args) {
        int[] ints1= new int[]{1,4,7,8,3,6,9};

        int[] merge = merge(ints1);

        print(merge);

    }


    private static int[] merge(int[] ints1) {
        int[] newInts = new int[ints1.length];
        int mid = newInts.length/2;
        int i=0,j=mid+1;
        int p=0;
        //第一想的，如图上第一第二张
        while(i<mid && j<ints1.length){
            newInts[p++]=ints1[i]>=ints1[j]?ints1[j++]:ints1[i++];
            /*if(ints1[i]>=ints1[j]){
                newInts[p++]= ints1[j++];
            }else{
                newInts[p++]= ints1[i++];
            }*/
        }
        //添加最后值
        while(i<=mid){
            newInts[p++]=ints1[i++];
        }
        while(j<=ints1.length-1){
            newInts[p]=ints1[j++];
        }
        return newInts;
    }

    public static void print(int[] ints){
        for(int i:ints){
            System.out.print(i);
        }
    }

}

因为要使用递归的排序，代码中merge并不灵活，因为最终往下分成一块一块，然后合并，所以merge这里缺少左指针，右指针，右边界
在这里插入图片描述

package com.my;

public class MergeSort {

    public static void main(String[] args) {
        int[] ints1= new int[]{1,4,7,8,3,6,9};
        int[] merge = merge(ints1,0,4,6);
        print(merge);

    }
    private static int[] merge(int[] ints1,int left,int right,int rightBorder) {
        //改变数值
        int[] newInts = new int[rightBorder-left+1];
        int mid = right;
        int i=left;
        int j=right;
        int p=0;

        while(i<=mid && j<rightBorder){
            newInts[p++]=ints1[i]>=ints1[j]?ints1[j++]:ints1[i++];
        }
        //添加最后值
        while(i<mid){
            newInts[p++]=ints1[i++];
        }
        while(j<=rightBorder){
            newInts[p]=ints1[j++];
        }
        return newInts;
    }

    public static void print(int[] ints){
        for(int i:ints){
            System.out.print(i);
        }
    }

}

最终代码

package com.my;

public class MergeSort {

    public static void main(String[] args) {
        int[] arrs= new int[]{1,4,7,8,3,6,9};
        sort(arrs,0,arrs.length-1);
        print(arrs);

    }

    private static void sort(int[] arrs,int L,int R) {
        //结束条件
        if(L==R)  return;
        //分成两半
        int mid = L+(R-L)/2;
        //左边排序,递归
        sort(arrs,L,mid);
        //右边排序，递归
        sort(arrs,mid+1,R);
        //合并
        merge(arrs,L,mid+1,R);
    }

    //假定排好序的情况下合并
    private static void merge(int[] arrs,int left,int right,int rightBorder) {
        //改变数值
        int[] newInts = new int[rightBorder-left+1];
        int mid = right-1;
        int i=left;
        int j=right;
        int p=0;

        while(i<=mid && j<=rightBorder){
            newInts[p++]=arrs[i]>arrs[j]?arrs[j++]:arrs[i++];
        }
        //添加最后值
        while(i<=mid){
            newInts[p++]=arrs[i++];
        }
        while(j<=rightBorder){
            newInts[p++]=arrs[j++];
        }
        //写回原先
        for(int m=0;m<newInts.length;m++) arrs[left+m] = newInts[m];
    }

    public static void print(int[] ints){
        for(int i:ints){
            System.out.print(i);
        }
    }
}

总结

要有递归的思想，而且要注意边界值

自行车在路上
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于Merge的整理--Merge的使用方法和注意事项的Demo
weixin_33906657的博客
10-18 3609
上一篇文章中讲到了Merge的用法和注意事项，所以本人就想，做了一个Demo进行验证下。 一、Merge的使用 （1）activity中的onCreate方法中的setContentView(R.layout.main2); （2）应用Include或者ViewStub标签从外部导入xml结构时，可以将被导入的xml用merge作为根节点表示，这样当被嵌入父级结构中后可以很好的将它所包含的子...
排序之归并排序
dong132697的博客
09-03 2万+
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。所谓归并，就是将两组有序的数据合成为一组有序的数据，例如有如下两个有序数组，将两个有序数组归并为一个有序数组，这就是一次归并操作。
归并排序（看了就会）
Circ
05-05 1万+
归并排序，是创建在归并操作上的一种有效的排序算法。上图中首先把一个未排序的序列从中间分割成2部分，再把2部分分成4部分，依次分割下去，直到分割成一个一个的数据，再把这些数据两两归并到一起，使之有序，不停的归并，最后成为一个排好序的序列。不管元素在什么情况下都要做这些步骤，所以花销的时间是不变的，所以该算法的最优时间复杂度和最差时间复杂度及平均时间复杂度都是一样的为：O( nlogn )归并排序算法中，归并最后到底都是相邻元素之间的比较交换，并不会发生相同元素的相对位置发生变化，故是稳定性算法。
MapReduce基础编程
m0_49972043的博客
04-24 2511
MapReduce基础编程快速解法合并去重整合排序信息挖掘 快速解法 跟着茂神的节奏，直接打印 合并去重 import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.Text; import org.apache.ha
排序算法-归并排序详细讲解（MergeSort）
GTW、Zeus的博客
07-11 1万+
归并，指合并，合在一起。归并排序（Merge Sort）是建立在归并操作上的一种排序算法。其主要思想是分而治之。若将两个有序集合并成一个有序表，称为2-路归并，与之对应的还有多路归并。借助一个辅助空数组，把左右两边的数组按照大小比较，按顺序放入辅助数组中即可。以下面两个有序数组为例： public static void mergeSort(int[] arr){ if (arr == null || arr.length<2){ return;
归并排序Java_归并排序_
10-04
归并排序是一种高效的排序算法，基于分治策略。在Java中实现归并排序，我们可以创建一个名为`MergeSort`的类来封装整个过程。归并排序的基本思想是将待排序的序列分成两个或更多的子序列，对每个子序列分别进行排序...
归并排序_归并排序_
10-01
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案&quot...
C++实现归并排序
12-20
【归并排序】是一种高效的排序算法，其基本思想源于分治法（Divide and Conquer）。归并排序通过不断地将数组划分为较小的子序列，然后对这些子序列进行排序，最后将排序好的子序列合并成一个完整的有序序列。在这个...
归并排序算法实现
03-16
### 归并排序算法实现详解 #### 一、引言 归并排序是一种经典的排序算法，采用分治法的思想，将待排序数组分为若干个子序列，这些子序列是已排序的，然后再按照一定的方式合并这些子序列得到最终排序后的数组。...
十大经典排序算法-归并排序算法详解
热门推荐
qq_35344198的博客
06-19 12万+
一、什么是归并排序 1.概念 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分 序列逐层拆分如下 然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并 创建一个大序列，序列长度为两个小序列长度
算法 - 归并排序（Merge_sort）
曾铎的博客
08-09 7624
在写归并排序的代码之前，我们先对归并排序的定义和排序原理进行梳理。是一类不同的排序方法。“归并”的含义是将两个或者两个以上的有序表组合成一个新的有序表。利用归并的思想容易实现排序，且这种实现方法已为读者熟悉，无论是顺序存储结构还是链表存储结构，都可以在O（m+n）的时间量级上实现。归并排序也是一个与插入排序、交换排序、选择排序不同的一类排序方法。归并排序是一个基于分治法思想的算法，拿两个已经有序的序列重新组合成一个有序的序列。..................
【算法系列 | 4】深入解析排序算法之——归并排序
颜淡慕潇
06-10 2万+
排序算法是很常见的一类问题，主要是将一组数据按照某种规则进行排序。以下是一些常见的排序算法：冒泡排序（Bubble Sort）插入排序（Insertion Sort）选择排序（Selection Sort）归并排序（Merge Sort）快速排序（Quick Sort）堆排序（Heap Sort）归并排序（Merge Sort）是一种基于分治思想的排序算法，它将待排序的数组分成两部分，分别对这两部分递归地进行排序，最后将两个有序子数组合并成一个有序数组。
归并排序 MergeSort
Withered Wood
01-28 4724
1. 基本思想 什么是归并排序？？ 归并排序是基于归并的排序。归并，是将两个或两个以上的有序表合成一个有序表。 假设待排序的数组有 n 个元素，将数组看成是 n 个有序的子数组，每个子数组只有一个元素。然后两两合并，得到每个子数组长度为2。然后继续两两合并，直到合并为长度为 n 的数组。 时间复杂度 平均复杂度是 O(nlogn)，最好复杂度是 O(nlogn)，最坏复杂度是 O(nlogn) 。 （图片来源于网络） 将原数组划分子数组的过程看成是一棵二叉树，那么数组划分到每个子数组中只有一个元素
非常详细——归并排序merge sort
czh_vegetable的博客
06-30 4849
归并排序
java算法原理
最新发布
jylee的博客
07-25 833
正确回答通过率：40.0%[ 详情 ] 推荐指数： ★★★★ 试题难度： 高难 试题类型： 编程题 ▸ 写笔记试题回答参考思路： >>
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值