一，歸併排序介紹

歸併排序是一個典型的基於分治的遞迴演算法。它不斷地將原陣列分成大小相等的兩個子陣列(可能相差1)，最終當劃分的子陣列大小為1時(下面程式碼第17行left小於right不成立時) ，將劃分的有序子陣列合併成一個更大的有序陣列。為什麼是有序子陣列？？？

歸併排序的遞迴公式：T(N) = 2T(N/2) + O(N)

從公式中可以看出：將規模為 N 的原問題分解成兩個規模 N/2 的兩個子問題；並且，合併這兩個子問題的代價是 O(N)---[後面的 +O(N) 表示合併的代價]

二，歸併排序演算法分析

 歸併排序演算法有兩個基本的操作，一個是分，也就是把原陣列劃分成兩個子陣列的過程。另一個是治，它將兩個有序數組合併成一個更大的有序陣列。

它將陣列平均分成兩部分: center = (left + right)/2，當陣列分得足夠小時---陣列中只有一個元素時，只有一個元素的陣列自然而然地就可以視為是有序的，此時就可以進行合併操作了。因此，上面講的合併兩個有序的子陣列，是從 只有一個元素 的兩個子陣列開始合併的。

合併後的元素個數：從 1-->2-->4-->8......

比如初始陣列：[24,13,26,1,2,27,38,15]

①分成了兩個大小相等的子陣列：[24,13,26,1]    [2,27,38,15]

②再劃分成了四個大小相等的子陣列：[24,13]   [26,1]    [2,27]    [38,15]

③此時，left < right 還是成立，再分：[24]   [13]   [26]    [1]    [2]     [27]    [38]   [15]

此時，有8個小陣列，每個陣列都可以視為有序的陣列了！！！，每個陣列中的left == right，從遞迴中返回(從19行--20行的程式碼中返回)，故開始執行合併(第21行)：

merge([24],[13]) 得到 [13,24]

merge([26],[1]) 得到[1,26]

.....

.....

最終得到 有序陣列。

三，歸併排序演算法實現

 1 public class MergeSort {
 
 2 
 3     public static <T extends Comparable<? super T>> void mergeSort(T[] arr) {
 4         T[] tmpArray = (T[]) new Comparable[arr.length];
 5         mergeSort(arr, tmpArray, 0, arr.length - 1);
 6     }
 7 
 8     /**
 9      * 
10      * @param arr an array of Comparable items
11      * @param tmpArray an array to place the merge result
12      * @param left the left-most index of the array
13      * @param right right-most index of the array
14      */
15     private static <T extends Comparable<? super T>> void mergeSort(T[] arr,
16             T[] tmpArray, int left, int right) {
17         if (left < right) {
18             int center = (left + right) / 2;
19             mergeSort(arr, tmpArray, left, center);
20             mergeSort(arr, tmpArray, center + 1, right);
21             merge(arr, tmpArray, left, center + 1, right);
22         }
23     }
24 
25     /**
26      * 
27      * @param arr an array of Comparable items
28      * @param tmpArray an array to place the merge result
29      * @param leftPos the left-most index of the subarray
30      * @param rightPos the index of the start of the second half
31      * @param rightEnd the right-most index of the subarray
32      */
33     private static <T extends Comparable<? super T>> void merge(T[] arr,
34             T[] tmpArray, int leftPos, int rightPos, int rightEnd) {
35         int leftEnd = rightPos - 1;
36         int numElements = rightEnd - leftPos + 1;
37         int tmpPos = leftPos;// 只使用tmpArray中某一部分割槽域
38         while (leftPos <= leftEnd && rightPos <= rightEnd) {
39             if (arr[leftPos].compareTo(arr[rightPos]) <= 0)
40                 tmpArray[tmpPos++] = arr[leftPos++];
41             else
42                 tmpArray[tmpPos++] = arr[rightPos++];
43         }
44 
45         while (leftPos <= leftEnd)
46             tmpArray[tmpPos++] = arr[leftPos++];// copy rest of left half
47         while (rightPos <= rightEnd)
48             tmpArray[tmpPos++] = arr[rightPos++];// copy rest of right half
49 
50         // copy tmpArray back
51         for (int i = 0; i < numElements; i++, rightEnd--)
52             arr[rightEnd] = tmpArray[rightEnd];//只拷貝當前 merge 的部分陣列
53 
54         /**
55          * 複製了整個陣列中的所有元素 
56           for(int i = 0; i < tmpArray.length; i++)
57                  arr[i] = tmpArray[i];
58          */
59     }
60     
61     //for test purpose
62     public static void main(String[] args) {
63         Integer[] arr = {24,13,26,1,2,27,38,15};
64         mergeSort(arr);
65         for (Integer i : arr)
66             System.out.print(i + " ");
67     }
68 }

①第3行的公共方法，是對外的排序介面，首先建立一個臨時陣列tmpArray，用來儲存合併過程中，兩個子陣列臨時合併的結果。將tmpArray作為引數傳遞給遞迴呼叫的方法，而不是在執行遞迴呼叫的方法裡面建立臨時陣列，這樣可以大大地減少臨時陣列的建立。若在遞迴呼叫的方法裡建立臨時陣列，每一層遞迴呼叫，都會建立一個臨時陣列。

②第15行的私有方法，是執行遞迴呼叫的方法。在某次具體的遞迴呼叫中，只用到了tmpArray中的某一部分空間(leftEnd 和 rightEnd之間的空間)。

③第38行while迴圈，比較兩個子陣列中的元素，誰小就把誰放到tmpArray中。

 ④第45行和第47行的兩個while迴圈完成的功能是：當合並兩個有序的子陣列時，一個子陣列中的元素已經全部放到tmpArray中去了，另一個子陣列中還剩下有元素，故將剩下的所有元素直接複製到tmpArray中。

⑤第51行for迴圈，將本次merge完成的兩個子陣列複製到原陣列中去。注意，它只複製本次參與合併的兩個子陣列中的元素。為什麼要複製到原陣列中去呢？因為在下一次的合併過程中，需要合併的是更大的子陣列，這個更大的陣列，就是由上次合併的生成的有序小陣列組成的。比如：

在合併這兩個陣列時：[24]   [13]

下一次合併的則是：[13,24]  [1,26]

四，歸併排序演算法複雜度分析

歸併排序中，用到了一個臨時陣列，故空間複雜度為O(N)

由歸併排序的遞迴公式：T(N) = 2T(N/2) + O(N) 可知時間複雜度為O(NlogN)

陣列的初始順序會影響到排序過程中的比較次數，但是總的而言，對複雜度沒有影響。平均情況 or 最壞情況下 它的複雜度都是O(NlogN)

此外，歸併排序中的比較次數是所有排序中最少的。原因是，它一開始是不斷地劃分，比較只發生在合併各個有序的子陣列時。

因此，JAVA的泛型排序類庫中實現的就是歸併排序。因為：對於JAVA而言，比較兩個物件的操作代價是很大的（根據Comparable介面的compareTo方法進行比較），而移動兩個物件，其實質移動的是引用，代價比較小。（排序本質上是兩種操作：比較操作和移動操作）

java.util.Arrays.sort(T[] arr)使用的是歸併排序

java.util.Arrays.sort(int[] arr) 使用的是快速排序

2018-11-24更新：

JDK7中使用 TimSort演算法取代了原來的歸併排序。優化點：①歸併排序中的“分”不再直至劃分到單個元素；②引入binarySort二分查詢思想。

五，參考資料