初級Java開發人員面試，經常會碰到技術面試官問排序演算法，幾乎每次面試一遍都要刷一遍排序演算法……,今天正在刷歸併排序，居然發現在100000級別的資料量中歸併演算法的執行時間居然比選擇排序要長，百思不得解，最後在比較多位大神blog中的程式碼實現，發現問題的根源，在此做一個記錄，也算是一個成長道路上的積累吧。

歸併排序演算法的實現步驟(網上貼的)
 * 把長度為n的輸入序列分成兩個長度為n/2的子序列；
 * 對這兩個子序列分別採用歸併排序；
 * 將兩個排序好的子序列合併成一個最終的排序序列。

選擇排序演算法實現：

    /**
     * 它的工作原理很容易理解： 1.初始時在序列中找到最小（大）元素，放到序列的起始位置作為已排序序列；
     * 2.然後，再從剩餘未排序元素中繼續尋找最小（大）元素，放到已排序序列的末尾； 3.以此類推，直到所有元素均排序完畢。
     *
     * @return
 
 int[]
     * @Author Administrator
     * @Date 2018年3月7日
     */
    public static void selectSort(int arr[]) {
        long start = System.currentTimeMillis();
        if (arr != null && arr.length > 1) {
            for (int i = 0; i < arr.length - 1; i++) {
                int min = i;
                for
 
 (int j = i + 1; j < arr.length; j++) {
                    if (arr[min] > arr[j]) {
                        min = j;
                    }
                }
                if (min != i) {
                    swap(arr, i, min);
                }
            }
        }
        System.out.println("select sort 耗時 ： "
 
 + (System.currentTimeMillis() - start) + "ms");
    }

第一版歸併演算法實現：

    /**
     * 歸併排序
     * 把長度為n的輸入序列分成兩個長度為n/2的子序列；
     * 對這兩個子序列分別採用歸併排序；
     * 將兩個排序好的子序列合併成一個最終的排序序列。
     * @param arr
     */
    public static void mergeSort(int[] arr) {
        if (arr == null || arr.length < 1) {
            return;
        }
        long start = System.currentTimeMillis();
        doMergeSort(arr, 0, arr.length-1);
        System.out.println("merge sort 耗時 ： " + (System.currentTimeMillis() - start) + "ms");
    }

    private static void doMergeSort(int[] arr, int start, int end) {
        if (start >=end) {
            return;
        }
        int mid = (start + end) >>1;

        doMergeSort(arr, start, mid);
        doMergeSort(arr, mid+1, end);
        merge(arr, start,mid, end);
    }

    /**
     *合併子序列
     * 
     * @param arr
     * @param start
     * @param end
     */
    private static void merge(int[] arr, int start,int mid, int end) {       *//注意此處，產生臨時資料表，儲存已經歸併了的子序列
        *int[] temp = new int[arr.length];*
        int tp=start,lp=start,rp=mid +1;
        while(lp<=mid&&rp<=end){
            if(arr[lp]<=arr[rp]){
                temp[tp++] =arr[lp++] ;
            }else{
                temp[tp++] =arr[rp++] ;
            }
        }
        while(lp<=mid){
            temp[tp++] =arr[lp++] ;
        }
        while(rp<=end){
            temp[tp++] =arr[rp++] ;
        }
        int cp =start;
        //從臨時陣列拷貝到原陣列
        while(cp<=end){
            arr[cp] = temp[cp];
            cp++;
        }
    }

執行結果比較：
資料量：10000
select sort 耗時 ： 62ms
merge sort 耗時 ： 112ms

歸併排序耗時近乎選擇排序耗時兩倍。

改良後的程式碼實現：

    /**
     * 歸併排序 把長度為n的輸入序列分成兩個長度為n/2的子序列；
     * 對這兩個子序列分別採用歸併排序；
     * 將兩個排序好的子序列合併成一個最終的排序序列。
     * 
     * @param arr
     */
    public static void mergeSort(int[] arr) {
        if (arr == null || arr.length < 1) {
            return;
        }
        long start = System.currentTimeMillis();
        int[] temp = new int[arr.length];
        doMergeSort(arr, 0, arr.length - 1,temp);
        System.out.println("merge sort 耗時 ： " + (System.currentTimeMillis() - start) + "ms");
    }

    private static void doMergeSort(int[] arr, int start, int end,int[] temp) {
        if (start >= end) {
            return;
        }
        int mid = (start + end) >> 1;

        doMergeSort(arr, start, mid,temp);
        doMergeSort(arr, mid + 1, end,temp);
        merge(arr, start, mid, end,temp);
    }

    /**
     * 合併子序列
     * 
     * @param arr
     * @param start
     * @param end
     */
    private static void merge(int[] arr, int start, int mid, int end,int[] temp) {

        // 此處new temp降低排序效能
        int tp = start, lp = start, rp = mid + 1;
        while (lp <= mid && rp <= end) {
            if (arr[lp] <= arr[rp]) {
                temp[tp++] = arr[lp++];
            } else {
                temp[tp++] = arr[rp++];
            }
        }
        while (lp <= mid) {
            temp[tp++] = arr[lp++];
        }
        while (rp <= end) {
            temp[tp++] = arr[rp++];
        }
        int cp = start;
        // 從臨時陣列拷貝到原陣列
        while (cp <= end) {
            arr[cp] = temp[cp];
            cp++;
        }
    }

效率比較：
select sort 耗時 ： 71ms
merge sort 耗時 ： 6ms

效率得到飛一般的提升，那麼兩種實現的為何會相差這麼多呢？
我的分析是在資料量大的時候，執行merge方法的次數必然增多，每呼叫merge方法，執行一次int[] temp = new int[arr.length];產生一個臨時物件，降低了效能。改良後的實現，在外部呼叫merge時把臨時資料表當做引用傳入方法中，在整個排序過程中始終始終只需要一個額外的臨時空間，因此效率得到大幅度上升。
網上有些Blog貼出的第一版的實現，再次我引以為鑑，踩過坑才能不入坑！