算法 - 归并排序

要点：先递归向下拆分，再递归向上合并，合并后的元素是有序的，分而治之的思想。

为了理解起来简单，算法内部多了数组的创建过程。是可以优化的，可以看一下其它的归并版本。

public class MergeSort<T extends Comparable> {

    private T[] sort(T[] arr, int left, int right) {
        // 拆分中点
        int middle = (right + left) / 2;
        // 如果只有一个数，即左标右标相等，跳出递归
        if (left == right) {
            return (T[]) new Comparable[]{arr[left]};
        }
        printSplit(arr, left, middle);
        // 左子列递归
        T[] leftArr = sort(arr, left, middle);
        printSplit(arr, middle + 1, right);
        // 右子列递归
        T[] rightArr = sort(arr, middle + 1, right);
        // 合并
        return merge(leftArr, rightArr);
    }

    private T[] merge(T[] leftArr, T[] rightArr) {
        int lengthLeft = leftArr.length;
        int lengthRight = rightArr.length;
        // 左子列的游标
        int left = 0;
        // 右子列的游标
        int right = 0;
        // 新建数组的游标
        int cur = 0;
        // 新建放合并元素的数组
        T[] mergeArr = (T[]) new Comparable[leftArr.length + rightArr.length];
        // 放满了就退出
        while (cur < mergeArr.length) {
            // 右标移动到末尾了，就把左子列的都放到数组里
            if (right == lengthRight) {
                while (left < lengthLeft) {
                    mergeArr[cur] = leftArr[left];
                    left++;
                    cur++;
                }
            }
            // 左子列的数比右子列的小，放到数组里，移动游标
            while (left < lengthLeft && leftArr[left].compareTo(rightArr[right]) <= 0) {
                mergeArr[cur] = leftArr[left];
                left++;
                cur++;
            }
            // 左子列移动到末尾了，就把右子列的都放到数组里
            if (left == lengthLeft) {
                while (right < lengthRight) {
                    mergeArr[cur] = rightArr[right];
                    right++;
                    cur++;
                }
            }
            // 右子列的数比左子列的小，放到数组里，移动游标
            while (right < lengthRight && rightArr[right].compareTo(leftArr[left]) < 0) {
                mergeArr[cur] = rightArr[right];
                right++;
                cur++;
            }
        }
        printMerge(mergeArr);
        return mergeArr;
    }

    private void printSplit(T[] arr, int left, int right) {
        String[] stringArr = new String[]{" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "};
        for (int i = left; i <= right; i++) {
            stringArr[i] = "*";
        }
        for (T n : arr) {
            System.out.print(n);
        }
        System.out.println();
        for (String s : stringArr) {
            System.out.print(s);
        }
        System.out.println(" => 拆分");
    }

    private void printMerge(T[] arr) {
        for (T n : arr) {
            System.out.print(n);
        }
        System.out.print(" => 合并");
        System.out.println();
    }

    public void sort(T[] arr) {
        Comparable[] newArr = sort(arr, 0, arr.length - 1);
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (T) newArr[i];
        }
    }

    public static void main(String[] args) {
        Integer[] arr = new Integer[]{1, 3, 8, 7, 6, 9, 5, 4, 3, 2, 0};
        MergeSort ms = new MergeSort();
        ms.sort(arr);
    }

    /**
     * 13876954320
     * ******      => 拆分
     * 13876954320
     * ***         => 拆分
     * 13876954320
     * **          => 拆分
     * 13876954320
     * *           => 拆分
     * 13876954320
     *  *          => 拆分
     * 13 => 合并
     * 13876954320
     *   *         => 拆分
     * 138 => 合并
     * 13876954320
     *    ***      => 拆分
     * 13876954320
     *    **       => 拆分
     * 13876954320
     *    *        => 拆分
     * 13876954320
     *     *       => 拆分
     * 67 => 合并
     * 13876954320
     *      *      => 拆分
     * 679 => 合并
     * 136789 => 合并
     * 13876954320
     *       ***** => 拆分
     * 13876954320
     *       ***   => 拆分
     * 13876954320
     *       **    => 拆分
     * 13876954320
     *       *     => 拆分
     * 13876954320
     *        *    => 拆分
     * 45 => 合并
     * 13876954320
     *         *   => 拆分
     * 345 => 合并
     * 13876954320
     *          ** => 拆分
     * 13876954320
     *          *  => 拆分
     * 13876954320
     *           * => 拆分
     * 02 => 合并
     * 02345 => 合并
     * 01233456789 => 合并
     *
     * 136789 - 02345 => 稳定性和合并过程说明
     * ^      . ^     => []
     * ^      .  ^    => 右比左小 => [0] => 【包含赋值和移动，下同】
     *  ^     .  ^    => 左比右小 => [0, 1]
     *  ^     .   ^   => 右比左小 => [0, 1, 2]
     *  ^     .   ^   => 左右相等，左侧含等号，右侧不含，跳过 => [0, 1, 2]
     *   ^    .   ^   => 左右相等，进入 => [0, 1, 2, 3]
     *   ^    .    ^  => 右比左小 => [0, 1, 2, 3, 3] => 顺序未改变，稳定
     *   ^    .     ^ => 右比左小 => [0, 1, 2, 3, 3, 4]
     *   ^    .      ^=> 右比左小 => [0, 1, 2, 3, 3, 4, 5] => 右标 = 右子列长度
     *    ^   .       => 左子列剩余元素移入数组 => [0, 1, 2, 3, 3, 4, 5, 6]
     *     ^  .       => 左子列剩余元素移入数组 => [0, 1, 2, 3, 3, 4, 5, 6, 7]
     *      ^ .       => 左子列剩余元素移入数组 => [0, 1, 2, 3, 3, 4, 5, 6, 7, 8]
     *       ^.       => 左子列剩余元素移入数组 => [0, 1, 2, 3, 3, 4, 5, 6, 7, 8, 9] => 左标 = 左子列长度
     * 游标cur = 数组长度，退出循环，完成合并过程
     *
     * 每层遍历一遍，遍历了logn次
     * => 遍历次数：nlogn
     * => 时间复杂度：O(nlogn)
     * => 稳定性：稳定
     *
     */

}