归并排序

　　只模拟合并的流程

package com.example.sort.merge;

public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {1, 4, 7, 8, 3, 6, 9};
        sort(arr);

//        print(arr);
    }

    /**
     * 归并排序
     *
     * @param arr
     */
    private static void sort(int[] arr) {
        // 默认第一位排好序，从第二位开始
        merge(arr);
    }

    /**
     * 模拟合并过程
     *
     * @param arr
     */
    private static void merge(int[] arr) {
        int mid = arr.length / 2;
        // 辅助空数组
        int[] temp = new int[arr.length];
        int i = 0; // 左侧有序数组的第一个指针
        int j = mid + 1; // 右侧有序数组第一个指针
        int k = 0; // temp 的第一个指针
        while (i <= mid && j < arr.length) {
            if (arr[i] <= arr[j]) {
                temp[k] = arr[i];
                i++;
                k++;
            }else {
                temp[k] = arr[j];
                j++;
                k++;
            }
        }
        // 左侧数组有结余
        while (i<=mid){
            temp[k++] = arr[i++];
        }
        // 右侧数组有结余
        while (j<arr.length){
            temp[k++] = arr[j++];
        }
        print(temp);

    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    private static void print(int[] arr) {
        System.out.println();
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

　　优化merge方法，提供三个参数

package com.example.sort.merge;

public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {1, 4, 7, 8, 3, 6, 9};
        sort(arr);

//        print(arr);
    }

    /**
     * 归并排序
     *
     * @param arr
     */
    private static void sort(int[] arr) {
        // 默认第一位排好序，从第二位开始
        merge(arr, 1, 4, arr.length - 1);
    }

    /**
     * 数组合并过程
     * @param arr 数组
     * @param leftPointer 左边有序数组左指针
     * @param rightPointer 右边有序数组左指针
     * @param rightBound 左边有序数组右边界
     */
    private static void merge(int[] arr, int leftPointer, int rightPointer, int rightBound) {
        // 辅助空数组
        int[] temp = new int[rightBound - leftPointer + 1];
        int i = leftPointer; // 左侧有序数组的第一个指针
        int j = rightPointer; // 右侧有序数组第一个指针
        int k = 0; // temp 的第一个指针
        while (i < rightPointer && j <= rightBound) {
            temp[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
        }
        // 左侧数组有结余
        while (i < rightPointer) {
            temp[k++] = arr[i++];
        }
        // 右侧数组有结余
        while (j <= rightBound) {
            temp[k++] = arr[j++];
        }
        print(temp);

    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    private static void print(int[] arr) {
        System.out.println();
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

　　优化加入递归

package com.example.sort.merge;

public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {1, 4, 7, 8, 3, 6, 9};
        sort(arr, 0, arr.length - 1);

        print(arr);
    }

    /**
     * 归并排序
     *
     * @param arr
     */
    private static void sort(int[] arr, int left, int right) {
        if (left == right) return;
        // 数组分两半
        int mid = left + (right - left) / 2;
        // 左边排序
        sort(arr, left, mid);
        // 右边排序
        sort(arr, mid + 1, right);
        merge(arr, left, mid+1, right);
    }

    /**
     * 数组合并过程
     *
     * @param arr          数组
     * @param leftPointer  左边有序数组左指针
     * @param rightPointer 右边有序数组左指针
     * @param rightBound   左边有序数组右边界
     */
    private static void merge(int[] arr, int leftPointer, int rightPointer, int rightBound) {
        if (leftPointer== rightPointer) return;
        // 辅助空数组
        int[] temp = new int[rightBound - leftPointer + 1];
        int i = leftPointer; // 左侧有序数组的第一个指针
        int j = rightPointer; // 右侧有序数组第一个指针
        int k = 0; // temp 的第一个指针
        while (i < rightPointer && j <= rightBound) {
            temp[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
        }
        // 左侧数组有结余
        while (i < rightPointer) {
            temp[k++] = arr[i++];
        }
        // 右侧数组有结余
        while (j <= rightBound) {
            temp[k++] = arr[j++];
        }
        for (int m = 0; m < temp.length; m++) {
            arr[leftPointer+m] = temp[m];
        }
//        print(temp);

    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    private static void print(int[] arr) {
        System.out.println();
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}