排序算法之歸併排序分析

歸併排序

排序思想：

歸併排序使用的就是分治思想，將一個大問題分解成小的子問題來解決。小的子問題解決了，大問題也就解決了。 

這種將大問題分解成小問題的思想與遞歸很像，分治和遞歸的區別就是：分治是一種解決問題的處理思想，遞歸是一種編程技巧

如果要排序一個數組，我們先把數組從中間分成前後兩部分，然後對前後兩部分分別排序，再將排好序的兩部分合併在一起，這樣整個數組就都有序了。 

歸併排序常用遞歸來實現，可以推出歸併排序的遞推公式和中止條件爲：

遞推公式：
merge_sort(p…r) = merge(merge_sort(p…q), merge_sort(q+1…r))
終止條件：
p == r 不用再繼續分解

 merge_sort(p…r) 表示：給下標從 p 到 r 之間的數組排序。

我們將這個排序問題轉化爲了兩個子問題，merge_sort(p…q) 和 merge_sort(q+1…r)

其中下標 q 等於 p 和 r 的中間位置，也就是 (p+r)/2。

當下標從 p 到 q 和從 q+1 到 r 這兩個子數組都排好序之後，我們再將兩個有序的子數組合併在一起

這樣下標從 p 到 r 之間的數據就也排好序了。

 

那麼，兩個有序的子數組又是如何合併的呢？

我們申請一個臨時數組 tmp，大小與 A[p…r]相同。

我們用兩個遊標 i 和 j，分別指向 A[p…q]和 A[q+1…r]的第一個元素。

比較這兩個元素 A[i]和 A[j]，如果 A[i]<=A[j]，我們就把 A[i]放入到臨時數組 tmp，並且 i 後移一位，否則將 A[j]放入到數組 tmp，j 後移一位。

繼續上述比較過程，直到其中一個子數組中的所有數據都放入臨時數組中，再把另一個數組中的數據依次加入到臨時數組的末尾

這個時候，臨時數組中存儲的就是兩個子數組合並之後的結果了。最後再把臨時數組 tmp 中的數據拷貝到原數組 A[p…r]中。

 

 

歸併排序的執行效率

我們假設對 n 個元素進行歸併排序需要的時間是 T(n)，那分解成兩個子數組排序的時間都是 T(n/2)。

而merge() 函數合併兩個有序子數組的時間複雜度是 O(n)。

歸併排序的時間複雜度的計算公式就是：

T(1) = C；   n=1時，只需要常量級的執行時間，所以表示爲C。
T(n) = 2*T(n/2) + n； n>1

分解計算過程：

T(n) = 2*T(n/2) + n          k = 1
     = 4*T(n/4) + 2*n        k = 2
     = 8*T(n/8) + 3*n        k = 3
     = 16*T(n/16) + 4*n      k = 4
     ......
     = 2^k * T(n/2^k) + k * n
     ......

T(n) = 2^kT(n/2^k)+kn。

歸併排序最後會將數組分解爲n=1時，當 T(n/2^k)=T(1) 時，也就是 n/2^k=1，我們得到 k=log2n 。

我們將 k 值代入上面的公式，得到 T(n)=Cn+nlog2n 。

如果我們用大 O 標記法來表示的話，T(n) 就等於 O(nlogn)。所以歸併排序的時間複雜度是 O(nlogn)。 

 

歸併排序的內存消耗

因爲歸併排序在合併兩個有序數組爲一個有序數組時，需要藉助額外的存儲空間。

儘管每次合併操作都需要申請額外的內存空間，但在合併完成之後，臨時開闢的內存空間就被釋放掉了。

在任意時刻，CPU 只會有一個函數在執行，也就只會有一個臨時的內存空間在使用。

而臨時內存空間最大也不會超過 n 個數據的大小，所以空間複雜度是 O(n)。

 

歸併排序的穩定性

在合併的過程中，如果 A[p…q]和 A[q+1…r]之間有值相同的元素，我們可以先把 A[p…q]中的元素放入 tmp 數組。

這樣就保證了值相同的元素，在合併前後的先後順序不變。所以，歸併排序是一個穩定的排序算法。

 

歸併排序的代碼實現

public class MergeSort {

  // 歸併排序算法, a是數組，n表示數組大小
  public static void mergeSort(int[] a, int n) {
    mergeSortInternally(a, 0, n-1);
  }

  // 遞歸調用函數
  private static void mergeSortInternally(int[] a, int p, int r) {
    // 遞歸終止條件
    if (p == r) return;

    // 取p到r之間的中間位置q,防止（p+r）的和超過int類型最大值
    int q = p + (r - p)/2;
    // 分治遞歸
    mergeSortInternally(a, p, q);
    mergeSortInternally(a, q+1, r);

    // 將A[p...q]和A[q+1...r]合併爲A[p...r]
    merge(a, p, q, r);
    //mergeBySentry(a, p, q, r);
  }

  private static void merge(int[] a, int p, int q, int r) {
    int i = p;
    int j = q+1;
    int k = 0; // 初始化變量i, j, k
    int[] tmp = new int[r-p+1]; // 申請一個大小跟a[p...r]一樣的臨時數組
    while (i<=q && j<=r) {
      if (a[i] <= a[j]) {
        tmp[k++] = a[i++]; // i++等於i:=i+1
      } else {
        tmp[k++] = a[j++];
      }
    }

    // 判斷哪個子數組中有剩餘的數據
    int start = i;
    int end = q;
    if (j <= r) {
      start = j;
      end = r;
    }

    // 將剩餘的數據拷貝到臨時數組tmp
    while (start <= end) {
      tmp[k++] = a[start++];
    }

    // 將tmp中的數組拷貝回a[p...r]
    for (i = 0; i <= r-p; ++i) {
      a[p+i] = tmp[i];
    }
  }

利用哨兵節點優化歸併排序

private static void mergeBySentry(int[] arr, int p, int q, int r) {
    int[] leftArr = new int[q - p + 2];
    int[] rightArr = new int[r - q + 1];

    for (int i = 0; i <= q - p; i++) {
      leftArr[i] = arr[p + i];
    }
    // 第一個數組添加哨兵（最大值）
    leftArr[q - p + 1] = Integer.MAX_VALUE;

    for (int i = 0; i < r - q; i++) {
      rightArr[i] = arr[q + 1 + i];
    }
    // 第二個數組添加哨兵（最大值）
    rightArr[r-q] = Integer.MAX_VALUE;

    int i = 0;
    int j = 0;
    int k = p;
    while (k <= r) {
      // 當左邊數組到達哨兵值時，i不再增加，直到右邊數組讀取完剩餘值，同理右邊數組也一樣
      if (leftArr[i] <= rightArr[j]) {
        arr[k++] = leftArr[i++];
      } else {
        arr[k++] = rightArr[j++];
      }
    }
  }
}