数据结构与算法--分治法、归并排序

分治法

分治法的思想是：将原问题分解成若干个规模较小但是与原问题类似的问题，递归地求解这些子问题，然后再合并这些子问题的解来建立原问题的解。

分治法在每层递归时都有三个步骤：

• 分解： 将原问题分解为若干个子问题，这些问题是原问题的规模较小的实例
• 解决： 递归求解子问题，若子问题规模足够小，则直接求解
• 合并： 合并这些子问题的解成原问题的解。

归并排序

归并排序就是采用分治法的思想。

• 分解： 分解待排序的$n$个元素的序列成各具$n/2$个元素的两个子序列。
• 解决： 递归排序两个子序列。
• 合并： 合并两个已排序的子序列以产生已排序的答案。

其递归思想如下图所示

将数组分为含有$n/2$个元素的两个数组，然后分别递归排序，然后再次拆分，直到最后只剩一个元素。然后开始归并。这个算法的难点在于子序列的合并，合并思想如下

首先需要创建一个数组，我们记为$S$，数组的长度为两个子序列之和。从两个子序列的最左端开始，谁的元素小（大）就将谁的放入到$S$中。

归并排序代码实现

public class MergeSort {

    public static int[] sort(int[] arr, int start, int end) {
        if (start == end) {
            // 如果开始索引和结束索引相等，说明只需处理一个元素，所以直接返回此元素即可。
            return new int[] {arr[start]};
        } else {
            // 这里减一不减一都可以，如果减一是把奇数元素的子序列放到了最右边，否则是放到了最左边来处理
            // 等价于(end-start)/2，由于位运算速度更快，所以这里使用位运算。
            int half = ((end - start - 1) >> 1);
            int[] left = sort(arr, start, start + half);
            int[] right = sort(arr, start + half + 1, end);

            // 合并子序列
            int maxLength = left.length + right.length;
            int[] mergeArr = new int[maxLength];
            int lIndex = 0;
            int rIndex = 0;
            for (int i = 0; i < maxLength; i++) {
                if (lIndex < left.length && rIndex < right.length) {
                    if (left[lIndex] <= right[rIndex]) {
                        mergeArr[i] = left[lIndex];
                        lIndex++;
                    } else {
                        mergeArr[i] = right[rIndex];
                        rIndex++;
                    }
                } else if (lIndex < left.length) {
                    mergeArr[i] = left[lIndex];
                    lIndex++;
                } else {
                    mergeArr[i] = right[rIndex];
                    rIndex++;
                }

            }
            return mergeArr;
        }
    }

    public static void main(String[] args) {
        int[] arr = {2, 5, 1, 8, 9, 7, 6, 12, 4};
        int[] sortRes = sort(arr, 0, arr.length - 1);
        for (int i : sortRes) {
            System.out.printf("%d\t", i);
        }
        System.out.println();
    }
}

时间复杂度分析

我们先看递归深度，从上面的图中我们能看出递归深度应该是$lo{g}_{2}n+1$。有根节点所以加一，最后一级如果不是满树的状态会被忽略掉。

设$c={\log }_{2}n$，那么递归式的和为${\sum }_{i=0}^c{2}^i$（从0开始是为了方便计算）。此算法中的基本操作就是合并，假设第一层的时间复杂度是$Cn$次，第二层每个递归就是$Cn/2$，以此类推，最后得到总的时间复杂度为：
$$\sum _{i=0}^c{2}^i\times \frac{Cn}{2^i}=\sum _{i=0}^{c}Cn=(c+1)Cn=Cnlo{g}_{2}n+Cn$$
舍去常数项和对算法影响较小的项最终就是$O(n{\log }_{2}n)$或者写为$O(n\log n)$在算法中$\log n$通常表示以2为底$n$的对数。