Java归并排序

归并排序就是将2个有序的序列合并起来，其时间复杂度为O(nlgn),而且它是一种稳定的排序，它的缺点是需要额外n的空间来辅助排序。

接下来看其Java实现

public class MergeSort {

    public static void main(String[] args) {
        Integer[] arr = {1, 6, 9, 3, 2, 11, 15, 4};
        mergeSort(arr);

        Arrays.sort(arr);
    }

    public static void mergeSort(Integer[] arr) {
        sort(arr, 0, arr.length - 1);
    }

    public static void sort(Integer[] arr, int left, int rigth) {
        if (left >= rigth) {
            return;
        }

        int center = (left + rigth) / 2;

        //对左边的进行递归排序
        sort(arr, left, center);

        //右边进行递归排序
        sort(arr, center + 1, rigth);

        //两边排序好的进行合并
        merge(arr, left, center, rigth);

        print(arr);
    }

    /**
     * 合并
     * @param arr
     * @param left
     * @param center
     * @param right
     */
    public static void merge(Integer[] arr, int left, int center, int right) {
        //辅助数组
        Integer[] aux = new Integer[arr.length];

        //辅助数组下标
        int auxIndex = left;

        //存储左边下标
        int temp = left;

        //中间的位置
        int mid = center;

        center += 1;

        //遍历比较直到有一边的数组比较完成
        while (left <= mid && center <= right) {
            if (arr[left] <= arr[center]) {
                aux[auxIndex++] = arr[left++];
            } else {
                aux[auxIndex++] = arr[center++];
            }
        }

        //下面2个while是将没有合并完成的一边放入数组
        while (left <= mid) {
            aux[auxIndex++] = arr[left++];
        }

        while (right >= (center)) {
            aux[auxIndex++] = arr[center++];
        }

        //将排序好的数组放回原数组中
        while (temp <= right) {
            arr[temp] = aux[temp++];
        }

    }

    /**
     * 打印数组
     * @param arr
     */
    public static void print(Integer[] arr) {
        for (Integer a : arr) {
            System.out.print(a + ", ");
        }
        System.out.println();
    }
}

过程就是递归排序两边的序列，然后将排序好的两边序列进行合并。

JDK中改进过的归并排序

jdk中的工具类对数组和list进行的排序便是改进过的归并排序

private static void mergeSort(Object[] src,
                  Object[] dest,
                  int low,
                  int high,
                  int off) {
    int length = high - low;

    // 数组小于7时将使用插入排序
        if (length < INSERTIONSORT_THRESHOLD) {
            for (int i=low; i<high; i++)
                for (int j=i; j>low &&
             ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                    swap(dest, j, j-1);
            return;
        }

        //从中间分两部分进行递归
        int destLow  = low;
        int destHigh = high;
        low  += off;
        high += off;
        int mid = (low + high) >>> 1;
        mergeSort(dest, src, low, mid, -off);
        mergeSort(dest, src, mid, high, -off);

       //如果一边最大的小于另一边最小的，直接合并
        if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
            System.arraycopy(src, low, dest, destLow, length);
            return;
        }

        // 将两边的序列进行合并
        for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
            if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }
    }