Java归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

排序过程图

排序思想

归并排序的主要思想就是先分割，再合并。
1.将整个数组折半分割，直到每个子数组都只有一个数。
2.再将每两个相邻的子数组结合。
3.创建一个新数组，来暂时保存数组。
4.一次比较两子数组中的值，将较小的值依次放入新数组中。
5.再将剩下未放入到新数组中的数，依次放入到新数组中。
6.当整个新数组都放满时，再用新数组的值覆盖掉之前数组的值。
3.不停地结合并排序，直到整个数组合并完成，则排序完成。

排序代码

public static void mergeSort(int[] arr){
	//数组的区间为闭区间
    mergeSortInternal(arr, 0, arr.length - 1);
}
private static void mergeSortInternal(int[] arr, int l, int r) {
    //求中间索引
    int mid = r + ((l - r) >> 1);
    //将左数组排序
    mergeSortInternal(arr, l, mid);
    //将右数组排序
    mergeSortInternal(arr, mid + 1, r);
    //若数组已排序成功，则返回
    //若数组还为排序成功，则将左右数组合在一起归并排序
    if (arr[mid] > arr[mid + 1]){
        merge(arr, l, mid, r);
    }
}
private static void merge(int[] arr, int l, int mid, int r) {
	//创建新数组，来暂时保存数组
    int[] newArr = new int[r - l + 1];
    //左数组的第一个索引
    int i = l;
    //右数组的第一个索引
    int j = mid + 1;
    //辅助数组的第一个索引
    int k = 0;
    //依次比较出较小的数，并放入到新数组中
    while (i <= mid && j <= r){
        if (arr[i] <= arr[j]){
            newArr[k++] = arr[i++];
        } else {
            newArr[k++] = arr[j++];
        }
    }
    //前数组有剩余的数
    while (i <= mid){
        newArr[k++] = arr[i++];
    }
    //后数组有剩余的数
    while (j <= r){
        newArr[k++] = arr[j++];
    }
    //将辅助数组的值赋给原数组
    for (int m = 0; m < newArr.length; m++) {
        arr[l + m] = newArr[m];
    }
}

代码改进——解决可能的栈溢出问题

代码改进思想

归并排序在执行时，需要多次调用函数，而当数据过多时，可能会出现栈溢出的问题，于是，可以在数组长度较短时，使用插入排序（在近乎有序的情况下，插入排序的效率高），来解决栈溢出的问题。

改进代码

public static void mergeSort(int[] arr){
	//数组的区间为闭区间
    mergeSortInternal(arr, 0, arr.length - 1);
}
private static void mergeSortInternal(int[] arr, int l, int r) {
    //若当前数组偿付较短时，使用插入排序，否则容易栈溢出
    if (r - l <= 15){
        insertSort(arr, l, r);
        return;
     }
    //求中间索引
    int mid = r + ((l - r) >> 1);
    //将左数组排序
    mergeSortInternal(arr, l, mid);
    //将右数组排序
    mergeSortInternal(arr, mid + 1, r);
    //若数组已排序成功，则返回
    //若数组还为排序成功，则将左右数组合在一起归并排序
    if (arr[mid] > arr[mid + 1]){
        merge(arr, l, mid, r);
    }
}
private static void merge(int[] arr, int l, int mid, int r) {
	//创建新数组，来暂时保存数组
    int[] newArr = new int[r - l + 1];
    //左数组的第一个索引
    int i = l;
    //右数组的第一个索引
    int j = mid + 1;
    //辅助数组的第一个索引
    int k = 0;
    //依次比较出较小的数，并放入到新数组中
    while (i <= mid && j <= r){
        if (arr[i] <= arr[j]){
            newArr[k++] = arr[i++];
        } else {
            newArr[k++] = arr[j++];
        }
    }
    //前数组有剩余的数
    while (i <= mid){
        newArr[k++] = arr[i++];
    }
    //后数组有剩余的数
    while (j <= r){
        newArr[k++] = arr[j++];
    }
    //将辅助数组的值赋给原数组
    for (int m = 0; m < newArr.length; m++) {
        arr[l + m] = newArr[m];
    }
}
//插入排序
public static void insertSort(int[] arr,int l,int r){
    for (int i = l + 1; i <= r; i++) {
        for (int j = i; j > l && arr[j] < arr[j - 1]; j--){
            swap(arr, j - 1, j);
        }
    }
}
private static void swap(int[] arr, int i, int j){
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}