归并排序：自顶向下（分治法），自底向上

最新推荐文章于 2021-10-30 22:27:53 发布

读源码的boy

最新推荐文章于 2021-10-30 22:27:53 发布

阅读量942

点赞数

CC 4.0 BY-SA版权

分类专栏：算法

本文链接：https://blog.youkuaiyun.com/w9l82l2w3z4z/article/details/84453437

算法专栏收录该内容

5 篇文章

订阅专栏

本文深入解析了归并排序算法的实现细节，包括不借助辅助数组和借助辅助数组的两种版本，以及自底向上的归并排序方法。文章还提供了完整的Java代码实现，涵盖了排序、合并操作、插入排序优化及数组比较等关键部分。

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

public class MergeSort {
    public  static  Comparable[] aux;
    /*50长度以下的数组 */
    public  static  int carry=50;
  //不借助辅存版本
    public static  void merge(Comparable[] a,Comparable[] dst,int lo,int mid,int hi){
        int i=lo,j=mid+1;
        /*for (int k = lo; k <=hi; k++) {
            aux[k]=a[k];
        }*/
        for (int k = lo; k <=hi; k++) {
            if(i>mid)
                dst[k]=a[j++];
            else if(j<hi)
                dst[k]=a[i++];
            else if(less(a[j],a[i]))
                dst[k]=a[j++];
            else
                dst[k]=a[i++];
        }
    }
   //借助辅存版本
    public static  void mergebu(Comparable[] a,int lo,int mid,int hi){
        int i=lo,j=mid+1;
        for (int k = lo; k <=hi; k++) {
            aux[k]=a[k];
        }
        for (int k = lo; k <=hi; k++) {
            if(i>mid)
                a[k]=aux[j++];
            else if(j<hi)
                a[k]=aux[i++];
            else if(less(aux[j],aux[i]))
                a[k]=aux[j++];
            else
                a[k]=aux[i++];
        }
    }
    public static  void sort(Comparable[] a){
           aux=new Comparable[a.length];

    }

    /*
    *
    *
    * */
    public static void sort(Comparable[] a,Comparable[] dst,int lo,int hi){
        if(lo<=hi) return;
        int mid=(lo+hi)/2;
        if((hi-lo)<carry){
            /*
            *如果子数组较小插入排序 减少递归函数调用
            *
            */
            insertsort(a,lo,hi);


        }else{
            sort(a,dst,lo,mid);
            sort(a,dst,mid+1,hi);
            /*
            * a[mid]小于a[mid+1] 因为 lo...mid mid+1....hi是有序的 数组是有序的
            *
            * */
            if(!less(a[mid],a[mid+1])){
                merge(a,dst,lo,mid,hi);
            }else{
                System.arraycopy(a,lo,dst,lo,hi-lo+1);
            }

        }


    }
    /*
    * 自底向上版本
    *
    * */
    public static  void sortbu(Comparable[] a){
        int N=a.length;
        aux=new Comparable[N];
        for (int i = 1; i <N ; i=i+i) {
            /*i 为 1 2 4 8正是象征着子数组主键变化的长度*/
            for(int lo=0;lo<N-i;lo+=i+i){
                mergebu(a,lo,lo+i-1,Math.min(lo+i+i,N-1));
            }
        }
    }

    private  static  boolean less(Comparable v,Comparable w){
        return v.compareTo(w)<0;
    }

    private  static  void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];a[i]=a[j];a[j]=t;
    }


    public  static  void insertsort(Comparable[] a,int lo,int hi){
        for (int i = lo; i <=hi; i++) {
            for (int j = i; j >lo&&less(a[j],a[j-1]) ; j--)
            exch(a,j,j-1);
        }
    }

    public  static boolean isSorted(Comparable[] a){
        for (int i = 0; i <a.length ; i++) {
            if(less(a[i],a[i])) return false;
         }
         return  true;
    }

    public  static  void main(String[] args){
        //String[] a=In.readStrings();
        String a[]={"123","23","123"};
        sort(a);
        
        System.out.println();
    }

}