归并排序（Java）

最新推荐文章于 2023-12-11 10:45:47 发布

枳洛淮南✘

最新推荐文章于 2023-12-11 10:45:47 发布

阅读量123

点赞数 1

分类专栏：排序 Java 文章标签：算法排序算法数据结构 java 快速排序

本文链接：https://blog.csdn.net/weixin_43520256/article/details/115347761

版权

Java 同时被 2 个专栏收录

124 篇文章 1 订阅

订阅专栏

排序

8 篇文章 0 订阅

订阅专栏

本文详细介绍了归并排序的原理，通过分治法将序列拆分成有序子序列再进行合并，确保完全有序。提供了随机数组、有序数组和逆序数组的示例，并展示归并排序过程。同时，给出了完整的Java实现代码，包括归并排序函数`mergeSort1`及其内部辅助方法。

摘要由CSDN通过智能技术生成

归并排序

原理

原理

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


import java.util.Arrays;
import java.util.Random;

/**
 * @author 枳洛淮南
 * @version 1.0
 * @Description 归并排序
 * @Date 2021/3/29 下午 21:20
 */
public class mergeSort
{

    public static long[] func() //随机数组
    {
        Random random = new Random(20210320);
        long[] array = new long[10];
        for (int i = 0; i < 10; i++)
        {
            array[i] = random.nextInt(100);
        }
        return array;
    }

    public static long[] func2()    //有序数组
    {
        long[] a = func();
        Arrays.sort(a);
        return a;
    }

    public static long[] func3()    //逆序数组
    {
        long[] a = func2();
        for (int i = 0; i < a.length / 2; i++)
        {
            long t = a[i];
            a[i] = a[a.length - i - 1];
            a[a.length - i - 1] = t;
        }
        return a;
    }

    public static void main(String[] args)
    {
        long[] a1 = func();
        System.out.println(Arrays.toString(a1));
        mergeSort1(a1);
        System.out.println(Arrays.toString(a1));
        System.out.println();

        long[] a2 = func2();
        System.out.println(Arrays.toString(a2));
        mergeSort1(a2);
        System.out.println(Arrays.toString(a2));
        System.out.println();

        long[] a3 = func3();
        System.out.println(Arrays.toString(a3));
        mergeSort1(a3);
        System.out.println(Arrays.toString(a3));
        System.out.println();
    }

    public static void mergeSort1(long[] array)
    {
        mergeSortInternal(array, 0, array.length);
    }

    private static void mergeSortInternal(long[] array, int lowIndex, int highIndex)
    {
        int size = highIndex - lowIndex;

        if (size <= 1)
        {
            return;
        }

        int middleIndex = (lowIndex + highIndex) / 2;
        mergeSortInternal(array, lowIndex, middleIndex);
        mergeSortInternal(array, middleIndex, highIndex);

        merge(array, lowIndex, middleIndex, highIndex);

    }

    private static void merge(long[] array, int lowIndex, int middleIndex, int highIndex)
    {
        int size = highIndex - lowIndex;
        long[] newArray = new long[size];

        int left = lowIndex, right = middleIndex, e = 0;

        while (left < middleIndex && right < highIndex)
        {
            if (array[left] <= array[right])
            {
                newArray[e] = array[left];
                left++;
                e++;
            } else
            {
                newArray[e] = array[right];
                right++;
                e++;
            }
        }

        if (left < middleIndex)
        {
            while (left < middleIndex)
            {
                newArray[e++] = array[left++];
            }
        } else
        {
            while (right < highIndex)
            {
                newArray[e++] = array[right++];
            }
        }
        if (size >= 0)
        {
            System.arraycopy(newArray, 0, array, lowIndex, size);
        }
    }
}