Java 排序算法-归并排序

算法思想

归并排序（MergeSort）是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

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

算法原理

归并算法的示意图（图片来自维基百科）

算法实现

使用递归的归并排序

public class TestJava {

    private static int[] array = new int[]{11, 4, 5, 6, 1, 2, 16, 3, 44, 21, 22, 8, 9, 7, 2, 6};

    public static void main(String[] args) {
        mergeSort(array, 0, array.length - 1);

        for (int k : array) {
            System.out.println("array:" + k);
        }
    }

    private static void mergeSort(int[] array, int left, int right) {

        if (left >= right) {
            return;
        }

        int middle = (left + right) / 2;

        int[] A = new int[middle - left + 1];
        int[] B = new int[right - middle];

        System.arraycopy(array, left, A, 0, A.length);
        System.arraycopy(array, middle + 1, B, 0, B.length);

        mergeSort(A, 0, A.length -1);
        mergeSort(B, 0, B.length - 1);


        int i = 0;
        int j = 0;

        for (int index = left; index <= right; index++) {
            if (i < A.length && j < B.length) {
                array[index] = A[i] < B[j] ?  A[i ++] : B[j ++];
            } else if (i < A.length) {
                array[index] = A[i ++];
            } else if (j < B.length) {
                array[index] = B[j ++];
            }
        }
    }
}

归并排序的优化（非递归归并排序）

public class CustomMergeSort {

    private static int[] array = new int[]{11, 4, 5, 6, 1, 2, 16, 3, 44, 21, 22, 8, 9, 7, 2, 6};

    public static void main(String[] args) {
        mergeSort();
        for (int i : array) {
            System.out.println(i);
        }
    }


    public static void mergeSort() {

        int len = array.length;

        int k = 1;

        while (k < len) {
            mergePass(array, k, len);
            k *= 2;
        }
    }


    private static void mergePass(int[] array, int k, int n) {
        int i = 0;

        while (i < n - 2 * k + 1) {
            merge(array, i , i + 2 * k - 1);
            i += 2* k;
        }

        if (i < n - k) {
            merge(array, i, n -1);
        }
    }


    private static void merge(int[] array, int left, int right) {

        if (left >= right) {
            return;
        }

        int middle = (left + right) / 2;

        int[] A = new int[middle - left + 1];
        int[] B = new int[right - middle];

        System.arraycopy(array, left, A, 0, A.length);
        System.arraycopy(array, middle + 1, B, 0, B.length);



        int i = 0;
        int j = 0;

        for (int index = left; index <= right; index++) {
            if (i < A.length && j < B.length) {
                array[index] = A[i] < B[j] ?  A[i ++] : B[j ++];
            } else if (i < A.length) {
                array[index] = A[i ++];
            } else if (j < B.length) {
                array[index] = B[j ++];
            }
        }
    }
}

算法分析

（1）稳定性
　归并排序是一种稳定的排序。
（2）存储结构要求
　可用顺序存储结构。也易于在链表上实现。
（3）时间复杂度
　对长度为n的文件，需进行 趟二路归并，每趟归并的时间为O(n)，故其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlgn)。
（4）空间复杂度
　 需要一个辅助向量来暂存两有序子文件归并的结果，故其辅助空间复杂度为O(n)，显然它不是就地排序。