归并排序详解(Java语言描述萌新向)

压力小子呀

已于 2022-11-04 23:33:24 修改

阅读量1k

点赞数 3

文章标签： java 排序算法算法

于 2022-11-04 23:31:57 首次发布

本文链接：https://blog.csdn.net/haijv/article/details/127697268

版权

一，归并排序简介

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

二，归并排序原理

1，先将一组数据尽可能拆分为两个元素相同的子组，直到拆分每个子组的元素为1。

2，将相邻的两个子组合并成一个有序的大组。

3，不断重复步骤2，知道只剩下一个组为止

三，归并排序图解

1，归并总体的图解

先是采用“分”将数组分开，然后是“治”将其合并，如下图：

2，合并两个子组的流程

归并排序的核心部分就是这个“合并”的流程，下面附上一部分的图解：

在对子组排序中我们引入的三个指针，p1指向了左子组，p2指向了右子组，i指向辅助数组（用于存放排序好的数据）。

先将p1,p2位置的数据进行比较，较小者放入辅助数组中，并将i指针和较小者的指针往前移一位，这便完成一次填充。

特殊情况：当有一个指针移到子组的末尾时，该指针则停止移动，另外一个指针和i指针继续移动。

3，归并排序动画演示

对于大部分来说动画一定是直观并且生动的，下面附上一段选自网上的归并排序算法，感受算法之美。

四，归并排序代码实现与分析（Java）

1，方法的合集

类名	Merge
构造方法	Merge()
成员方法	public static void sort(Comparable[] a);//对数组内元素进行排序 private static void sort(Comparable[] a,int low, int high); //重载方法 private static void merge(Comparable[] a,int low, int mid, int high); //完成归并的关键方法 private static boolean less(Comparable v,Comparable w); //比较v元素是否小于v元素
成员变量	private static Comparable[] assist; //完成归并操作的辅助数组

2，Merge类各方法的解析

(1)对数组内元素进行排序，sort方法：

//对数组内元素进行排序
    public static void sort(Comparable[] a){
        //初始化assist
        assist = new Comparable[a.length];
        //定义low和high分别表示最小和最大索引
        int low = 0;
        int high = a.length-1;
        //调用sort重载方法完成数组a中的low 到 high 的排序
        sort(a,low,high);

    }

(2)sort的重载方法，引入了数组的头尾索引:low 和 high

 //对数组a中 索引low 到 索引high 之间的元素进行排序
    private static void sort(Comparable[] a,int low, int high){
        //安全性校验 当high<=low时结束方法
        if (high<=low){
            return;
        }
        //将a数组low 到 high分为两组
        int mid = (high+low)/2;
        //分别对每一组数据进行排序 利用了重载方法
        sort(a,low,mid);
        sort(a,mid+1,high);
        //将两组数据进行归并
        merge(a,low,mid,high);
    }

方法中mid变量用于将数组分组。

(3)merge方法，用于归并子组，是该算法的核心部分：

    //将索引low到索引mid为一个子组,mid+1到high为另一个子组，将这两个子组合成为一个有序大组
    private static void merge(Comparable[] a,int low, int mid, int high){

        //定义3个指针 分别指向辅助数组assist两个子组
        int i = low;
        int p1 = low;
        int p2 = mid+1;

        //移动p1 p2 比较对应索引的值并加到辅助数组对应索引处
        while (p1<=mid && p2<=high){
            if (less(a[p1],a[p2])){
                assist[i++]=a[p1++];
            }else {
                assist[i++]=a[p2++];
            }
        }
        //p1没有走完
        while (p1<=mid){
            assist[i++]=a[p1++];
        }
        //p2没有走完
        while (p2<=high){
            assist[i++]=a[p2++];
        }

        //将排序好的assist数组的数据拷贝到数组a对应位置
        for (int index=low;index<=high;index++){
            a[index]=assist[index];
        }

    }

注：

(i)第一个while循环是两个指针都未到末尾移动的情况。

(ii)后二个while循环用于两个指针分别走到末尾的情况。

(iii) assist[i++]=a[p1++]，表示将a[p1]的值赋给assist[i]并将两个指针往后移一位。

(4)less方法，比较两个元素大小，在方法merge中调用过

 //比较v元素是否小于w元素
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }

3，Merge类全部代码

public class Merge {

    //辅助数组
    private static Comparable[] assist;

    //对数组内元素进行排序
    public static void sort(Comparable[] a){
        //初始化assist
        assist = new Comparable[a.length];
        //定义low和high分别表示最小和最大索引
        int low = 0;
        int high = a.length-1;
        //调用sort重载方法完成数组a中的low 到 high 的排序
        sort(a,low,high);

    }

    //对数组a中 索引low 到 索引high 之间的元素进行排序
    private static void sort(Comparable[] a,int low, int high){
        //安全性校验 当high<=low时结束方法
        if (high<=low){
            return;
        }
        //将a数组low 到 high分为两组
        int mid = (low+high)/2;
        //分别对每一组数据进行排序
        sort(a,low,mid);
        sort(a,mid+1,high);
        //将两组数据进行归并
        merge(a,low,mid,high);

    }

    //将索引low到索引mid为一个子组,mid+1到high为另一个子组，将这两个子组合成为一个有序大组
    private static void merge(Comparable[] a,int low, int mid, int high){

        //定义3个指针 分别指向辅助数组assist两个子组
        int i = low;
        int p1 = low;
        int p2 = mid+1;

        //移动p1 p2 比较对应索引的值并加到辅助数组对应索引处
        while (p1<=mid && p2<=high){
            if (less(a[p1],a[p2])){
                assist[i++]=a[p1++];
            }else {
                assist[i++]=a[p2++];
            }
        }
        //p1没有走完
        while (p1<=mid){
            assist[i++]=a[p1++];
        }
        //p2没有走完
        while (p2<=high){
            assist[i++]=a[p2++];
        }

        //将排序好的assist数组的数据拷贝到数组a对应位置
        for (int index=low;index<=high;index++){
            a[index]=assist[index];
        }

    }


    //比较v元素是否小于w元素
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }
}

4，测试和运行

先创建一个测试类MergeTest:

import java.util.Arrays;

public class MergeTest {
    public static void main(String[] args) {

        Integer[] a1 = {4,2,5,3,6,1,8,7};
        System.out.println("--------------a1排序前--------------");
        System.out.println(Arrays.toString(a1));
        Merge.sort(a1); //进行排序
        System.out.println("--------------a1排序后--------------");
        System.out.println(Arrays.toString(a1));

        Integer[] a2 = {5,6,3,1,8,7,2,4,10};
        System.out.println("--------------a2排序前--------------");
        System.out.println(Arrays.toString(a2));
        Merge.sort(a2); //进行排序
        System.out.println("--------------a2排序后--------------");
        System.out.println(Arrays.toString(a2));

        Integer[] a3 = {9,4,5,1,8,0,1,3,6};
        System.out.println("--------------a3排序前--------------");
        System.out.println(Arrays.toString(a3));
        Merge.sort(a3); //进行排序
        System.out.println("--------------a3排序后--------------");
        System.out.println(Arrays.toString(a3));
    }
}

运行结果：