排序算法-归并排序的时间复杂度分析-CSDN博客

本文链接：https://blog.csdn.net/shengqianfeng/article/details/100036856

本文深入解析归并排序算法，阐述其递归与合并过程，展示如何通过分治思想实现高效排序，同时分析归并排序的时间复杂度、空间复杂度及稳定性。

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

归并排序，其实就是递归+合并。

归并排序将数组取中间分为两部分，两个子数组分别各自再从中间分为两个子数组，一直分下去直到不能再分。分完之后，再按照子数组大小合并为为一个有序数组，然后层层向上合并，直到合并为一个有序的数组。

文字描述不理解的话，使用一副图来解释下：

其实归并排序的思想很简单，图中也描述的很清楚。

归并排序的时间复杂度为O(nlogn),跟冒泡、选择、插入这三种排序O(n^2)的时间复杂度不同，要有效率很多。

我们把代码呈上：

 /**
     * 归并排序
     * @param arr
     * @param n
     */
    public static void mergeSort(int[] arr,int n){
        mergeSort(arr,0,n-1);
    }

    /**
     * 递归程序
     * @param arr
     * @param p
     * @param r
     *
     */
    public static void mergeSort(int[] arr,int p,int r){
        if(p>=r){
            return;
        }
        int q = (p+r)/2;
        mergeSort(arr,p,q);
        mergeSort(arr,q+1,r);
        //合并
        merge(arr,p,q,r);
    }

    /**
     * 合并
     * @param arr
     * @param p
     * @param q
     * @param r
     */
    public static void merge(int[] arr,int p,int q,int r){
        int i =p,j=q+1,k=0;
        int[] temp = new int[r-p+1];
        while(i<=q && j<=r){
            //当两个区间中元素相等的时候，取arr(p,q)得加入temp，可以做到归并算法的稳定性
            if(arr[i] <= arr[j]){
                temp[k++]=arr[i++];
            }else{
                temp[k++]=arr[j++];
            }
        }
        //判断arr(p,q)和arr(q+1,r)哪个有剩余的数据
        int start=i,end=q;
        if(j<=r){
            start=j;
            end=r;
        }
        //将剩余数据拷贝到临时数组temp中
        while(start <= end){
            temp[k++]=arr[start++];
        }

        //将temp中的数据拷贝回arr(p,r)数组中
        for (int l = 0; l <= r-p; l++) {
            arr[p+l]=temp[l];
        }
    }

归并排序使用的是分治思想，分治思想简单说就是分而治之，将一个大问题分解为小问题，将小问题解答后合并为大问题的答案。乍一看跟递归思想很像，确实如此，分治思想一般就是使用递归来实现的。

需要说明的是，递归是代码实现，分治思想是解决问题的方法论，属于理论层面的。

其实mergeSort这个函数就是使用递归层层分解问题的。可以看到将数组的大区间[p,r]从中间分开，分成两个小区间[p,q]和[q+1,r]

/**
     * 递归程序
     * @param arr
     * @param p
     * @param r
     *
     */
    public static void mergeSort(int[] arr,int p,int r){
        if(p>=r){
            return;
        }
        int q = (p+r)/2;
        mergeSort(arr,p,q);
        mergeSort(arr,q+1,r);
        //合并
        merge(arr,p,q,r);
    }

层层分解，直到满足递归终止条件：p>=r,就说明分到最后1个不能再分了。既然无法再分，那接着就进行合并了。看起来merge函数写的很复杂，其实如果理解了思想就非常容易理解了，千万不能被吓到。一切反动派都是纸老虎！