演算法思想

歸併排序（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)，顯然它不是就地排序。