java归并排序

/**
 * Copyright (C), 2018-2019, LMaWC
 * FileName: Application
 * Author:   neo
 * Date:     2019/3/20 19:35
 * Description:
 * History:
 * <author>          <time>          <version>          <desc>
 * 作者姓名           修改时间           版本号              描述
 */
package com.test;

import com.sun.jndi.cosnaming.CNCtx;
import org.omg.CORBA.ARG_IN;
import sun.security.util.Length;

import javax.swing.text.Highlighter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * 〈一句话功能简述〉<br> 
 * 〈〉
 *
 * @author neo
 * @create 2019/3/20
 * @since 1.0.0
 */
public class Application {
    private static  void mergeSort(int[] a,int[] tmpArray,int left,int right){
        if(left<right){
            // 分成两个数组进行排序
            int center = (left+right)/2;
            mergeSort(a,tmpArray,left,center);
            mergeSort(a,tmpArray,center+1,right);

            // 将两个数组进行合并
            merge(a,tmpArray,left,center+1,right);
        }
    }

    public static void mergeSort(int[] a){
        int[] tmpArray = new int[a.length];
        mergeSort(a,tmpArray,0,a.length-1);
    }

    private static void merge(int[] a,int[] tmpArray,int lefPos,int rightPos,int rightEnd){
        int leftEnd = rightPos-1;
        int tmpPos = lefPos;
        int numElements = rightEnd-lefPos+1;

        // Main loop
        while (lefPos<=leftEnd&&rightPos<=rightEnd){
            // 把比较的数据全都放到tmp数组里
            if(a[lefPos]<=a[rightPos]){
                tmpArray[tmpPos++] = a[lefPos++];
            }else {
                tmpArray[tmpPos++] = a[rightPos++];
            }
        }
        while (lefPos<=leftEnd){
            tmpArray[tmpPos++] = a[lefPos++];
        }
        while (rightPos<=rightEnd){
            tmpArray[tmpPos++] = a[rightPos++];
        }

        // copy tmpArray back
        for(int i = 0;i< numElements;i++,rightEnd--){
            a[rightEnd] = tmpArray[rightEnd];
        }
    }

    public static void main(String[] args) {
        int[] nums={11,1,6,1,6,7,1,7,12};
        mergeSort(nums);
        for(int  i = 0;i<nums.length;i++){
            System.out.println(nums[i]);
        }
    }




}

 

### 归并排序的基本原理 归并排序是一种经典的排序算法,其核心思想是**分治法**。它通过将数组分成若干子序列,对每个子序列进行排序,然后再将它们合并为一个有序的序列。具体步骤包括: - **分解**:将待排序序列分成两个子序列。 - **解决**:递归地对两个子序列进行归并排序。 - **合并**:将两个有序的子序列合并成一个有序的序列。 归并排序具有稳定性和较好的时间复杂度,适用于大规模数据的排序。其时间复杂度为 $ 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、付费专栏及课程。

余额充值