算法 归并排序的复杂度分析（含图解流程和Master公式）

版权声明：作者: 阿顾, 转载请写明出处, 谢谢 https://blog.csdn.net/u010452388/article/details/81008727

图解流程

整体流程如下：

---

细节流程：
第一步：

---

第二步：

---

第三步：

---

第四步：

---

第五步：

---

第六步：

---

第七步：

---

第八步：

---

第九步：

---

第十步：

代码

public static void mergeSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        mergeSort(arr, 0, arr.length - 1);
    }

    public static void mergeSort(int[] arr, int L, int R) {
        if (L == R) {
            return;
        }
        int mid = (L + R) / 2;
        //将数组左侧全部排成有序
        mergeSort(arr, L, mid);//T(N/2)
        //将数组右侧全部排成有序
        mergeSort(arr, mid + 1, R);//T(N/2)
        merge(arr, L, mid, R);//O(N):因为N个数的话，需要依次扫过去
    }

    private static void merge(int[] arr, int L, int mid, int R) {
        //开辟一个临时数组，用来存放归并过程中的排好序的元素
        int[] help = new int[R - L + 1];
        //临时数组的索引
        int i = 0;
        int p1 = L;
        int p2 = mid + 1;
        while (p1 <= mid && p2 <= R) {
            if (arr[p1] <= arr[p2]) {
                help[i] = arr[p1];
                i++;
                p1++;
            } else {
                help[i] = arr[p2];
                i++;
                p2++;
            }
        }
        while (p1 <= mid) {
            help[i] = arr[p1];
            i++;
            p1++;
        }
        //上面的while循环和下面的while循环只会执行一个
        while (p2 <= R) {
            help[i] = arr[p2];
            i++;
            p2++;
        }
        for (int j = 0; j < help.length; j++) {
            // 这里要用arr[L+j]接受，因为每次进来归并排序的数组起始索引是L，长度是help的长度
            arr[L + j] = help[j];
        }
    }

Master公式

T(N) = a*T(N/b) + O(N^d)
1) 如果log(b,a) > d –> 复杂度为O(N^log(b,a))
2) 如果log(b,a) = d –> 复杂度为O(N^d * logN)
3) 如果log(b,a) < d –> 复杂度为O(N^d)

时间复杂度和额外空间复杂度

时间复杂度：

1、我们设mergeSort的时间复杂度为T(N)
2、从宏观上看，他分别调用了两次自己的函数mergeSort和一次merge,那么T(N)等于两次mergeSort的时间复杂度和一次merge的时间复杂度
3、调用自己的函数的时候，函数个数为N/2，则T(N)=2*T(N/2)+一次merge的时间复杂度
4、根据上面的流程分析merge总共扫描了N个数，执行了N次，所以时间复杂度为O(N)
5、所以T(N)=2*(N/2)+O(N)
6、根据Master公式，此时a=2,b=2,d=1,满足log(b,a) = d
7、所以归并排序时间复杂度为：O(N^d * logN)=O(N* logN)

额外空间复杂度：
因为我们每次执行merge的时候，都需要创建一个help数组，而这个help最大是N个数，需要N个空间，所以额外空间复杂度为O(N)，稳定性排序