[Java]归并排序

本文详细介绍了Java实现的二路归并排序算法,包括基本思想、迭代算法及具体代码实现,通过实例展示了如何将两个有序表合并为一个有序表。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

归并排序的思想是:将几个相邻的有序表合成一个总的有序表。

1、两个有序表合并

二路归并排序的基本操作是将两个相邻的有序表合并成一个有序表。

2、二路归并排序的迭代算法

二路归并的基本思想是:只有一个元素的表总是有序的,所以将排序表R[1…n],看做是n个长度为len=1的有序子表,对相邻的两个有序字表两两合并到R1[1..n],使之生成表长len=2的有序表;再进行两两合并到R[1..n]中,直到最后生成表长len=n的有序表。

java代码及运行结果(可直接使用):


public class MergeSort {
    public static void main(String[] args)
    {
        int number1[]={1,3,5,7,9,2,4,6,8};
        System.out.println("排序的两个数字表:");
        System.out.print("(1) ");
        for(int i=0;i<5;i++)
        {
            System.out.print(number1[i]);
            System.out.print(" ");
        }
        System.out.print("\n(2) ");
        for(int i=5;i<number1.length;i++)
        {
            System.out.print(number1[i]);
            System.out.print(" ");
        }
        int length=number1.length;
        int[] RS = new int[length];

        /*-------------- 两个有序表归并---------------*/
        System.out.println("\n两个有序表归并");
        Merge(number1,RS,0,4,8);
        for(int i=0;i<RS.length;i++)
        {
            System.out.print(RS[i]);
            System.out.print(" ");
        }


        int number2[]={1,3,5,7,9,2,4,6,8};
        int[] RX = new int[length];
        /*-------------- 二路归并---------------*/
        System.out.println("\n二路归并");
        Merge_Sort(number2,RX);
        for(int i=0;i<RX.length;i++)
        {
            System.out.print(RX[i]);
            System.out.print(" ");
        }
    }

    //归并排序
    //空间复杂度为O(n);时间复杂度为(nlogn)
    public static void Merge_Sort(int[] R,int[] RS)
    {
        int len=1;
        while(len<R.length)
        {
            MergePass(R,RS,len);
            len=2*len;
            MergePass(RS,R,len);
        }
    }

    public static void MergePass(int[] R,int[] RS,int len)
    {
        int i;
        for(i=0;i+2*len-1<=R.length-1;i=i+2*len)
        {
            Merge(R,RS,i,i+len-1,i+2*len-1);
        }
        if(i+len-1<R.length-1)
        {
            Merge(R,RS,i,i+len-1,R.length-1);
        }
        else if(i<=R.length-1)
        {
            while(i<=R.length-1)
            {
                RS[i]=R[i];
                i++;
            }
        }
    }

    public static void Merge(int[] R,int[] RS,int s,int m,int t)
    {
        int i,j,k;
        i=s;
        j=m+1;
        k=s;
        while(i<=m&&j<=t)
        {
            if(R[i]<R[j])
            {
                RS[k++]=R[i++];
            }
            else
            {
                RS[k++]=R[j++];
            }
        }
        while(i<=m)
        {
            RS[k++]=R[i++];
        }
        while(j<=t)
        {
            RS[k++]=R[j++];
        }
    }
}

这里写图片描述

### 归并排序的基本原理 归并排序是一种经典的排序算法,其核心思想是**分治法**。它通过将数组分成若干子序列,对每个子序列进行排序,然后再将它们合并为一个有序的序列。具体步骤包括: - **分解**:将待排序序列分成两个子序列。 - **解决**:递归地对两个子序列进行归并排序。 - **合并**:将两个有序的子序列合并成一个有序的序列。 归并排序具有稳定性和较好的时间复杂度,适用于大规模数据的排序。其时间复杂度为 $ O(N \log N) $,其中 $ N $ 是数据量。这是因为将数列分开成小数列一共要 $ \log N $ 步,每步都是一个合并有序数列的过程,时间复杂度为 $ O(N) $,因此总的时间复杂度为 $ O(N \log N) $。 ### Java 实现归并排序算法 以下是一个基于分治思想的 Java 实现示例: ```java public class MergeSort { // 主方法,用于启动归并排序 public static void mergeSort(int[] array) { if (array == null || array.length <= 1) { return; } mergeSort(array, 0, array.length - 1); } // 递归实现归并排序 private static void mergeSort(int[] array, int left, int right) { if (left >= right) { return; } int mid = (left + right) / 2; mergeSort(array, left, mid); // 对左半部分排序 mergeSort(array, mid + 1, right); // 对右半部分排序 merge(array, left, mid, right); // 合并两个有序部分 } // 合并两个子数组的方法 private static void merge(int[] array, int left, int mid, int right) { // 创建临时数组 int[] temp = new int[right - left + 1]; int i = left, j = mid + 1, k = 0; // 比较左右子数组元素,按顺序放入临时数组 while (i <= mid && j <= right) { if (array[i] <= array[j]) { temp[k++] = array[i++]; } else { temp[k++] = array[j++]; } } // 将剩余的左半部分元素复制到临时数组 while (i <= mid) { temp[k++] = array[i++]; } // 将剩余的右半部分元素复制到临时数组 while (j <= right) { temp[k++] = array[j++]; } // 将临时数组的元素复制回原数组 for (int p = 0; p < temp.length; p++) { array[left + p] = temp[p]; } } // 测试归并排序 public static void main(String[] args) { int[] data = {38, 27, 43, 3, 9, 82, 10}; System.out.println("排序前的数组:"); for (int num : data) { System.out.print(num + " "); } mergeSort(data); System.out.println("\n排序后的数组:"); for (int num : data) { System.out.print(num + " "); } } } ``` ### 归并排序的优化方法 归并排序在实现时可以进行一些优化,以进一步提高性能: - **小数组优化**:当子数组长度较小时,可以采用插入排序替代归并排序,因为插入排序在小规模数据上具有更低的常数因子。 - **避免额外空间拷贝**:可以通过交替使用主数组和辅助数组来减少数据拷贝的开销。 - **自然归并排序**:利用输入数据中已存在的有序段,减少分割步骤,提高效率。 ### 应用场景 归并排序由于其稳定的 $ O(N \log N) $ 时间复杂度,特别适用于: - **外部排序**:处理大规模数据,尤其是当数据存储在外部存储器(如硬盘)时。 - **链表排序**:归并排序适合链表结构,因为它不需要随机访问,而只需要顺序访问。 - **需要稳定排序的场景**:例如在数据库中对记录进行排序时,需要保持相同键值的原始顺序。 ### 优缺点分析 **优点**: - 时间复杂度稳定为 $ O(N \log N) $,适用于大规模数据。 - 是一种稳定排序算法,适合需要保持相同元素顺序的场景。 - 适用于链表结构的排序。 **缺点**: - 需要额外的存储空间,空间复杂度为 $ O(N) $。 - 对于小规模数据,效率不如插入排序等简单算法。 ### 归并排序的扩展 归并排序还可以扩展为**多路归并排序**,即每次将数组分成多个子序列进行排序,然后再合并。这种变体在处理分布式数据或外部排序时非常有用。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值