归并排序详解与实现-优快云博客

本文介绍了归并排序的定义，通过将长度为1的子序列逐步归并，最终得到有序序列的过程。归并排序的时间复杂度为O(nlogn)。文章还提及将采用递归方式来实现该排序算法。

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

定义：

假设一个序列有n个记录，可以被看成是n个长度为1的子序列，将这些子序列两两归并，等到一个长度为2的子序列，再两两归并，直到子序列长度为n，就得到了一个有序的序列。

时间复杂度：O(nlogn)

实现：

1、递归实现

public class merge {
    public void sort(int[] arr){
        int[] newarr= new int[arr.length];
        msort(arr,newarr,0,arr.length-1);
    }


    /**
     *递归实现
     * @param arr
     * @param begin
     * @param end
     * @return
     */
    private void msort(int[] arr,int[] newarr,int begin,int end){
        int[] tarr=new int[arr.length];
        if(begin == end){
            newarr[begin]=arr[begin];
        }else{
            int mid=(begin+end)/2;
            msort(arr,tarr,begin,mid);
            msort(arr,tarr,mid+1,end);
            mergearr(tarr,newarr,begin,mid,end);
        }
        SortUtils.print(newarr);
    }


    private void mergearr(int[] arr,int[] newarr,int begin,int mid,int end){
        int i,j,k;
        for(i=begin,j=mid+1,k=i;i<=mid && j<=end;k++){
            if(arr[i]<arr[j]){
                newarr[k]=arr[i];
                i++;
            }else{
                newarr[k]=arr[j];
                j++;
            }
        }
        if(i<=mid){
            for(int m=0;m<=mid-i;m++){
                newarr[k+m]=arr[i+m];
            }
        }
        if(j<=end){
            for(int m=0;m<=end-j;m++){
                newarr[k+m]=arr[j+m];
            }
        }
    }


    public static void main(String[] args){
        int[] arr= SortUtils.getArray();
        merge merge=new merge();
        merge.sort(arr);
    }
}

2、非递归实现

public class merge {
  
    public void sort(int[] arr){
        int k=1;
        int[] newarr=new int[arr.length];
        while(k<arr.length){
            psort(arr,newarr,k,arr.length);
            //SortUtils.print(newarr);
            k=k*2;
            psort(newarr,arr,k,arr.length);
            k=k*2;
            //SortUtils.print(arr);
        }
    }


    /**
     *非递归实现
     * @param arr
     * @param newarr
     * @param k
     * @param len
     */
    private void psort(int[] arr,int[] newarr,int k,int len){
        System.out.println("k:"+k);
        int i=0;
        while(i +2*k-1<len){
            mergearr(arr,newarr,i,i+k-1,i+2*k-1);
            i=i+2*k;
            SortUtils.print(newarr);
        }
        if(i+k < len){
            mergearr(arr,newarr,i,i+k-1,len-1);
            System.out.print("merge:");
            SortUtils.print(newarr);
        }else{
            for(int j=i;j<len;j++){
                newarr[j]=arr[j];
            }
            System.out.print("move:");
            SortUtils.print(newarr);
        }

    }

    private void mergearr(int[] arr,int[] newarr,int begin,int mid,int end){
        int i,j,k;
        for(i=begin,j=mid+1,k=i;i<=mid && j<=end;k++){
            if(arr[i]<arr[j]){
                newarr[k]=arr[i];
                i++;
            }else{
                newarr[k]=arr[j];
                j++;
            }
        }
        if(i<=mid){
            for(int m=0;m<=mid-i;m++){
                newarr[k+m]=arr[i+m];
            }
        }
        if(j<=end){
            for(int m=0;m<=end-j;m++){
                newarr[k+m]=arr[j+m];
            }
        }
    }


    public static void main(String[] args){
        int[] arr= SortUtils.getArray();
        merge merge=new merge();
        merge.sort(arr);
    }
}