分治法

分治法的设计思想是：将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。

分治法策略是：对于一个规模为n的问题，若该问题可以容易地解决（比如说规模n较小）则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立且与原问题形式相同，递归地解这些子问题，然后将各子问题的解合并得到原问题的解。这种算法设计策略叫做分治法。

分治法所能解决的问题一般具有以下几个特征：
1) 该问题的规模缩小到一定的程度就可以容易地解决
2) 该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质。
3) 利用该问题分解出的子问题的解可以合并为该问题的解；
4) 该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题。

如果具备了第一条和第二条特征，而不具备第三条特征，则可以考虑用贪心法或动态规划法。

分治法在每一层递归上都有三个步骤：
step1 分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题；
step2 解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题
step3 合并：将各个子问题的解合并为原问题的解。

Java代码：

public class MergeSorter {
    private MergeSorter() {}

    public static void sort(int[] a, int fromIndex, int toIndex) {
        if (fromIndex + 1 < toIndex) {
            int middle = (fromIndex + toIndex) / 2;
            sort(a, fromIndex, middle);
            sort(a, middle, toIndex);
            merge(a, fromIndex, middle, toIndex);
        }
    }

    /*
     * 这里在每次Merge时都创建一个比较小的临时数组，实际上在sort之前就创建一个大的数组
     * 会更好，这是我在查看Arrays.sort(Object[] a)的源代码时发现的。
     */
    private static void merge(int[] a, int fromIndex, int middle, int toIndex) {
        int[] leftArray = new int[middle - fromIndex];
        System.arraycopy(a, fromIndex, leftArray, 0, leftArray.length);
        int[] rightArray = new int[toIndex - middle];
        System.arraycopy(a, middle, rightArray, 0, rightArray.length);

        int i = 0;          // pointer to left array
        int j = 0;          // pointer to right array
        int k = fromIndex;  // pointer to whole array
        while (i < leftArray.length && j < rightArray.length) {
            if (leftArray[i] < rightArray[j]) {
                a[k++] = leftArray[i++];
            } else {
                a[k++] = rightArray[j++];
            }
        }
        while (i < leftArray.length) {
            a[k++] = leftArray[i++];
        }
        while (j < rightArray.length) {
            a[k++] = rightArray[j++];
        }
    }

    public static void sort(int[] a) {
        sort(a, 0, a.length);
    }

    public static void sort(Object[] a, int fromIndex, int toIndex) {
        if (fromIndex + 1 < toIndex) {
            int middle = (fromIndex + toIndex) / 2;
            sort(a, fromIndex, middle);
            sort(a, middle, toIndex);
            merge(a, fromIndex, middle, toIndex);
        }
    }


    @SuppressWarnings("unchecked")
    private static void merge(Object[] a, int fromIndex, int middle, int toIndex) {
        Object[] leftArray = new Object[middle - fromIndex];
        System.arraycopy(a, fromIndex, leftArray, 0, leftArray.length);
        Object[] rightArray = new Object[toIndex - middle];
        System.arraycopy(a, middle, rightArray, 0, rightArray.length);

        int i = 0;          // pointer to left array
        int j = 0;          // pointer to right array
        int k = fromIndex;  // pointer to whole array
        while (i < leftArray.length && j < rightArray.length) {
            if (((Comparable)leftArray[i]).compareTo(rightArray[j]) < 0) {
                a[k++] = leftArray[i++];
            } else {
                a[k++] = rightArray[j++];
            }
        }
        while (i < leftArray.length) {
            a[k++] = leftArray[i++];
        }
        while (j < rightArray.length) {
            a[k++] = rightArray[j++];
        }
    }

    public static void sort(Object[] a) {
        sort(a, 0, a.length);
    }

    public static <T> void sort(T[] a, Comparator<? super T> c) {
        sort(a, 0, a.length, c);
    }

    public static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c) {
        if (fromIndex + 1 < toIndex) {
            int middle = (fromIndex + toIndex) / 2;
            sort(a, fromIndex, middle, c);
            sort(a, middle, toIndex, c);
            merge(a, fromIndex, middle, toIndex, c);
        }
    }

    @SuppressWarnings("unchecked")
    private static <T> void merge(T[] a, int fromIndex, int middle, int toIndex, Comparator<? super T> c) {
        T[] leftArray = (T[]) new Object[middle - fromIndex];
        System.arraycopy(a, fromIndex, leftArray, 0, leftArray.length);
        T[] rightArray = (T[]) new Object[toIndex - middle];
        System.arraycopy(a, middle, rightArray, 0, rightArray.length);

        int i = 0;          // pointer to left array
        int j = 0;          // pointer to right array
        int k = fromIndex;  // pointer to whole array
        while (i < leftArray.length && j < rightArray.length) {
            if (c.compare(leftArray[i], rightArray[j]) < 0) {
                a[k++] = leftArray[i++];
            } else {
                a[k++] = rightArray[j++];
            }
        }
        while (i < leftArray.length) {
            a[k++] = leftArray[i++];
        }
        while (j < rightArray.length) {
            a[k++] = rightArray[j++];
        }
    }
}

注：代码来自算法导论的Java实现