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

一、归并排序介绍

• 归并排序（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秒