【算法】归并排序的分析

小yang_

于 2022-09-24 21:59:54 发布

阅读量394

点赞数 1

文章标签：算法 java 排序算法

本文链接：https://blog.csdn.net/m0_69976836/article/details/127031435

版权

归并排序

百度上对归并排序有这样的定义：归并排序是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

具体排序的做法描述如下：首先把一个未排序的序列从中间分割成2部分，再把2部分分成4部分，依次分割下去，直到分割成一个一个的数据，再把这些数据两两归并到一起，使之有序，不停的归并，最后成为一个排好序的序列。

动画演示

该排序的代码实现如下：

public class merge {
    public static void mergeSort(int[] arr) {
        if (arr == null || arr.length < 2)
            return;
        process(arr, 0, arr.length - 1);
        for (int i : arr) {
            System.out.println(i);
        }
    }

    public static void process(int[] arr, int L, int R) {//对数组中L到R位置的数进行排序
        if (L == R)
            return;
        int M = L + ((R - L) >> 1);//取中点，>>1等价于除以2
        process(arr, L, M);
        process(arr, M + 1, R);//通过递归调用process方法，数组中的数据全被分成两两一组,之后即进行归并排序
        merge(arr, L, M, R);//调用merge方法进行排序
    }

    public static void merge(int[] arr, int L, int M, int R) {
        int[] help = new int[R - L + 1];//申请一个辅助空间长度为数据两两递归合并后的长度（每归并一次长度翻倍）
        int i = 0;//help数组的下标
        int p1 = L;
        int p2 = M + 1;

        while (p1 <= M && p2 <= R) {//当p1和p2都不越界的情况下
            //比较两个数组首下标位置的数，把小的赋给辅助数组，然后该下标（首数据小的数组）后移，辅助数组下标后移
            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }

        //当上边的while执行后，必有p1或p2位置上的数赋给help数组，之后p1或p2后移后必有该数组的下标越界。
        //因此下边两个while会有一个符合（p2或p1），把此位置的数也存进help数组，然后此数组下标后移，help下标后移。
        //这就进行了一次排序，之后反复进行。
        while (p1 <= M) {
            help[i++] = arr[p1++];
        }
        while (p2 <= R) {
            help[i++] = arr[p2++];
        }
        for (i = 0; i < help.length; i++) {
            arr[L + i] = help[i];//把help数组拷贝到原数组
        }
    }

    public static void main(String[] args) {
        int[] array = {3, 6, 1, 2, 4, 2, 7, 4, 1, 0, 5};
        mergeSort(array);
    }
}

归并排序的时间复杂度求法

可推得此算法的master公式为

T(N) = 2T(N/2) + O(N)

在此公式中，a=2,b=2,d=1，所以logba=d,所以时间复杂度为O(N*logN)