10种排序算法五：归并排序 - 稳定

归并排序

/**
 * 排序算法五：归并排序 - 稳定
 * 【思想】：开辟一个新数组，将原数组进行多次对半分，每次都有leftBound（左边界），right（下标位置），rightBound(右边界)，直到不可再分为止（递归终止条件），然后对每小段数组进行合并并把值写到新数组。递归再将数组二分进行排序。
 * 与快排相比，归并排序是通过下标进行操作；
 * 【空间复杂度】n
 * 【时间复杂度】n*logN
 */
public class MergeSort {

    public static void main(String[] args) {
        // 假设两段均长有序数组
        int[] arr = {1, 2, 6, 11, 5, 14, 19, /**/ 5, 7, 8, 9, 10, 55};
        sort(arr, 0, arr.length - 1);
    }

    public static void sort(int[] arr, int leftPointer, int rightBound) {
//        System.out.println("leftPointer=" + leftPointer + ";rightBound=" + rightBound);
//        System.out.println(leftPointer == rightBound);
        if (leftPointer == rightBound) return;
        //分成两半
        int mid = (leftPointer + rightBound) / 2;
        //排序左边
        sort(arr, leftPointer, mid);
        //排序右边
        sort(arr, mid + 1, rightBound);
        //最后再次合并
        merge(arr, leftPointer, mid + 1, rightBound);
    }


    /**
     * 假定两段数组是有序的，此方法只做归并操作。前提是排序段是两个有序的数组
     *
     * @param arr          整个数组
     * @param leftPointer  需要排序段的左边界，数组下标
     * @param rightPointer 需要排序段的中间位置，数组下标
     * @param rightBound   需要排序段的右边界，数组下标
     */
    public static void merge(int[] arr, int leftPointer, int rightPointer, int rightBound) {
        int[] target = new int[rightBound - leftPointer + 1];
//        arr = {1, 2, 6, 11, 14, 19, 22, /**/ 5, 7, 8, 9, 10, 55};
        int mid = rightPointer - 1;
        int i = leftPointer;
        int j = rightPointer;
        int k = 0;
        while (i <= mid && j <= rightBound) {
            if (arr[i] >= arr[j]) {  //这里是要加上等于，如果不加上等于，那么这个算法是稳定的。
                target[k++] = arr[j++];
            } else {
                target[k++] = arr[i++];
            }
        }

        // 分别处理两段中没有被比较完的数
        while (i <= mid) target[k++] = arr[i++];
        while (j <= rightBound) target[k++] = arr[j++];

        for (int m = 0; m < target.length; m++) {
            arr[leftPointer + m] = target[m];
        }

        System.out.println(Arrays.toString(target));
        System.out.println("------------");
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 简易版本：
     * 归并排序：第一种情况，对多段有序数组排序
     * 假设排序数组分为两个从小到大的有序数组。如下
     */
    public static void merge0(int[] arr) {
        int mid = arr.length / 2;
        int[] target = new int[arr.length];

        int i = 0;
        int j = mid + 1;    //如果数组长度是奇数
//        int j = mid;      //如果数组长度是偶数
        int k = 0;
        while (i <= mid && j < arr.length) {
//        while (i < mid && j < arr.length) { //如果数组长度是偶数
            if (arr[i] >= arr[j]) {  //这里是要加上等于，如果不加上等于，那么这个算法是稳定的。
                target[k++] = arr[j++];
            } else {
                target[k++] = arr[i++];
            }
        }

        // 分别处理两段中没有被比较完的数
        while (i <= mid) target[k++] = arr[i++];    //如果数组长度是偶数
        while (j < arr.length) target[k++] = arr[j++];
        System.out.println(Arrays.toString(target));
    }

}