排序（下）：如何用開排思想在O（n）內查找第K大元素

上一節我講了冒泡排序、插入排序、選擇排序這三種排序算法，它們的時間復雜度都是 O(n2)，比較高，適合小規模數據的排序。今天，我講兩種時間復雜度為 O(nlogn) 的排序算法，歸并排序和快速排序。這兩種排序算法適合大規模的數據排序，比上一節講的那三種排序算法要更常用。

歸并排序和快速排序都用到了分治思想，非常巧妙。我們可以借鑒這個思想，來解決非排序的問題，比如：如何在 O(n) 的時間復雜度內查找一個無序數組中的第 K 大元素？ 這就要用到我們今天要講的內容。

歸并排序的原理

我們先來看歸并排序（Merge Sort）。

歸并排序的核心思想還是蠻簡單的。如果要排序一個數組，我們先把數組從中間分成前后兩部分，然后對前后兩部分分別排序，再將排好序的兩部分合并在一起，這樣整個數組就都有序了。

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

從我剛才的描述，你有沒有感覺到，分治思想跟我們前面講的遞歸思想很像。是的，分治算法一般都是用遞歸來實現的。分治是一種解決問題的處理思想，遞歸是一種編程技巧，這兩者并不沖突。分治算法的思想我后面會有專門的一節來講，現在不展開討論，我們今天的重點還是排序算法。

前面我通過舉例讓你對歸并有了一個感性的認識，又告訴你，歸并排序用的是分治思想，可以用遞歸來實現。我們現在就來看看如何用遞歸代碼來實現歸并排序。

我在第 10 節講的遞歸代碼的編寫技巧你還記得嗎？寫遞歸代碼的技巧就是，分析得出遞推公式，然后找到終止條件，最后將遞推公式翻譯成遞歸代碼。所以，要想寫出歸并排序的代碼，我們先寫出歸并排序的遞推公式。

遞推公式：
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 之間的數據就也排好序了。

有了遞推公式，轉化成代碼就簡單多了。為了閱讀方便，我這里只給出偽代碼，你可以翻譯成你熟悉的編程語言。

// 歸并排序算法, A 是數組，n 表示數組大小
merge_sort(A, n) {
  merge_sort_c(A, 0, n-1)
}
 
// 遞歸調用函數
merge_sort_c(A, p, r) {
  // 遞歸終止條件
  if p >= r  then return
 
  // 取 p 到 r 之間的中間位置 q
  q = (p+r) / 2
  // 分治遞歸
  merge_sort_c(A, p, q)
  merge_sort_c(A, q+1, r)
  // 將 A[p...q] 和 A[q+1...r] 合并為 A[p...r]
  merge(A[p...r], A[p...q], A[q+1...r])
}

你可能已經發現了，merge(A[p…r], A[p…q], A[q+1…r]) 這個函數的作用就是，將已經有序的 A[p…q] 和 A[q+1…r] 合并成一個有序的數組，并且放入 A[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] 中。

我們把 merge() 函數寫成偽代碼，就是下面這樣：

merge(A[p...r], A[p...q], A[q+1...r]) {
  var i := p，j := q+1，k := 0 // 初始化變量 i, j, k
  var tmp := new array[0...r-p] // 申請一個大小跟 A[p...r] 一樣的臨時數組
  while i<=q AND j<=r do {
    if A[i] <= A[j] {
      tmp[k++] = A[i++] // i++ 等于 i:=i+1
    } else {
      tmp[k++] = A[j++]
    }
  }
  
  // 判斷哪個子數組中有剩余的數據
  var start := i，end := q
  if j<=r then start := j, end:=r
  
  // 將剩余的數據拷貝到臨時數組 tmp
  while start <= end do {
    tmp[k++] = A[start++]
  }
  
  // 將 tmp 中的數組拷貝回 A[p...r]
  for i:=0 to r-p do {
    A[p+i] = tmp[i]
  }
}

你還記得第 7 講講過的利用哨兵簡化編程的處理技巧嗎？merge() 合并函數如果借助哨兵，代碼就會簡潔很多，這個問題留給你思考。

歸并排序的性能分析

這樣跟著我一步一步分析，歸并排序是不是沒那么難啦？還記得上節課我們分析排序算法的三個問題嗎？接下來，我們來看歸并排序的三個問題。

第一，歸并排序是穩定的排序算法嗎？

結合我前面畫的那張圖和歸并排序的偽代碼，你應該能發現，歸并排序穩不穩定關鍵要看 merge() 函數，也就是兩個有序子數組合并成一個有序數組的那部分代碼。

在合并的過程中，如果 A[p…q] 和 A[q+1…r] 之間有值相同的元素，那我們可以像偽代碼中那樣，先把 A[p…q] 中的元素放入 tmp 數組。這樣就保證了值相同的元素，在合并前后的先后順序不變。所以，歸并排序是一個穩定的排序算法。

第二，歸并排序的時間復雜度是多少？

歸并排序涉及遞歸，時間復雜度的分析稍微有點復雜。我們正好借此機會來學習一下，如何分析遞歸代碼的時間復雜度。

在遞歸那一節我們講過，遞歸的適用場景是，一個問題 a 可以分解為多個子問題 b、c，那求解問題 a 就可以分解為求解問題 b、c。問題 b、c 解決之后，我們再把 b、c 的結果合并成 a 的結果。

如果我們定義求解問題 a 的時間是 T(a)，求解問題 b、c 的時間分別是 T(b) 和 T( c)，那我們就可以得到這樣的遞推關系式：
T(a) = T(b) + T(c) + K

其中 K 等于將兩個子問題 b、c 的結果合并成問題 a 的結果所消耗的時間。

從剛剛的分析，我們可以得到一個重要的結論：不僅遞歸求解的問題可以寫成遞推公式，遞歸代碼的時間復雜度也可以寫成遞推公式。

套用這個公式，我們來分析一下歸并排序的時間復雜度。

我們假設對 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) 呢？還不夠直觀？那我們再進一步分解一下計算過程。

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

通過這樣一步一步分解推導，我們可以得到 T(n) = 2^kT(n/2k)+kn。當 T(n/2^k)=T(1) 時，也就是 n/2^k=1，我們得到 k=log2n 。我們將 k 值代入上面的公式，得到 T(n)=Cn+nlog2n 。如果我們用大 O 標記法來表示的話，T(n) 就等于 O(nlogn)。所以歸并排序的時間復雜度是 O(nlogn)。

從我們的原理分析和偽代碼可以看出，歸并排序的執行效率與要排序的原始數組的有序程度無關，所以其時間復雜度是非常穩定的，不管是最好情況、最壞情況，還是平均情況，時間復雜度都是 O(nlogn)。

第三，歸并排序的空間復雜度是多少？

歸并排序的時間復雜度任何情況下都是 O(nlogn)，看起來非常優秀。（待會兒你會發現，即便是快速排序，最壞情況下，時間復雜度也是 。）但是，歸并排序并沒有像快排那樣，應用廣泛，這是為什么呢？因為它有一個致命的“弱點”，那就是歸并排序不是原地排序算法。

這是因為歸并排序的合并函數，在合并兩個有序數組為一個有序數組時，需要借助額外的存儲空間。這一點你應該很容易理解。那我現在問你，歸并排序的空間復雜度到底是多少呢？是 O(n)，還是 O(nlogn)，應該如何分析呢？

如果我們繼續按照分析遞歸時間復雜度的方法，通過遞推公式來求解，那整個歸并過程需要的空間復雜度就是 O(nlogn)。不過，類似分析時間復雜度那樣來分析空間復雜度，這個思路對嗎？

實際上，遞歸代碼的空間復雜度并不能像時間復雜度那樣累加。剛剛我們忘記了最重要的一點，那就是，盡管每次合并操作都需要申請額外的內存空間，但在合并完成之后，臨時開辟的內存空間就被釋放掉了。在任意時刻，CPU 只會有一個函數在執行，也就只會有一個臨時的內存空間在使用。臨時內存空間最大也不會超過 n 個數據的大小，所以空間復雜度是 O(n)。

快速排序的原理

我們再來看快速排序算法（Quicksort），我們習慣性把它簡稱為“快排”。快排利用的也是分治思想。乍看起來，它有點像歸并排序，但是思路其實完全不一樣。我們待會會講兩者的區別。現在，我們先來看下快排的核心思想。

快排的思想是這樣的：如果要排序數組中下標從 p 到 r 之間的一組數據，我們選擇 p 到 r 之間的任意一個數據作為 pivot（分區點）。

我們遍歷 p 到 r 之間的數據，將小于 pivot 的放到左邊，將大于 pivot 的放到右邊，將 pivot 放到中間。經過這一步驟之后，數組 p 到 r 之間的數據就被分成了三個部分，前面 p 到 q-1 之間都是小于 pivot 的，中間是 pivot，后面的 q+1 到 r 之間是大于 pivot 的。

根據分治、遞歸的處理思想，我們可以用遞歸排序下標從 p 到 q-1 之間的數據和下標從 q+1 到 r 之間的數據，直到區間縮小為 1，就說明所有的數據都有序了。

如果我們用遞推公式來將上面的過程寫出來的話，就是這樣：

遞推公式：
quick_sort(p…r) = quick_sort(p…q-1) + quick_sort(q+1, r)
 
終止條件：
p >= r

我將遞推公式轉化成遞歸代碼。跟歸并排序一樣，我還是用偽代碼來實現，你可以翻譯成你熟悉的任何語言。

// 快速排序，A 是數組，n 表示數組的大小
quick_sort(A, n) {
  quick_sort_c(A, 0, n-1)
}
// 快速排序遞歸函數，p,r 為下標
quick_sort_c(A, p, r) {
  if p >= r then return
  
  q = partition(A, p, r) // 獲取分區點
  quick_sort_c(A, p, q-1)
  quick_sort_c(A, q+1, r)
}

歸并排序中有一個 merge() 合并函數，我們這里有一個 partition() 分區函數。partition() 分區函數實際上我們前面已經講過了，就是隨機選擇一個元素作為 pivot（一般情況下，可以選擇 p 到 r 區間的最后一個元素），然后對 A[p…r] 分區，函數返回 pivot 的下標。

如果我們不考慮空間消耗的話，partition() 分區函數可以寫得非常簡單。我們申請兩個臨時數組 X 和 Y，遍歷 A[p…r]，將小于 pivot 的元素都拷貝到臨時數組 X，將大于 pivot 的元素都拷貝到臨時數組 Y，最后再將數組 X 和數組 Y 中數據順序拷貝到 A[p…r]。

但是，如果按照這種思路實現的話，partition() 函數就需要很多額外的內存空間，所以快排就不是原地排序算法了。如果我們希望快排是原地排序算法，那它的空間復雜度得是 O(1)，那 partition() 分區函數就不能占用太多額外的內存空間，我們就需要在 A[p…r] 的原地完成分區操作。

原地分區函數的實現思路非常巧妙，我寫成了偽代碼，我們一起來看一下。

partition(A, p, r) {
  pivot := A[r]
  i := p
  for j := p to r-1 do {
    if A[j] < pivot {
      swap A[i] with A[j]
      i := i+1
    }
  }
  swap A[i] with A[r]
  return i

這里的處理有點類似選擇排序。我們通過游標 i 把 A[p…r-1] 分成兩部分。A[p…i-1] 的元素都是小于 pivot 的，我們暫且叫它“已處理區間”，A[i…r-1] 是“未處理區間”。我們每次都從未處理的區間 A[i…r-1] 中取一個元素 A[j]，與 pivot 對比，如果小于 pivot，則將其加入到已處理區間的尾部，也就是 A[i] 的位置。

數組的插入操作還記得嗎？在數組某個位置插入元素，需要搬移數據，非常耗時。當時我們也講了一種處理技巧，就是交換，在 O(1) 的時間復雜度內完成插入操作。這里我們也借助這個思想，只需要將 A[i] 與 A[j] 交換，就可以在 O(1) 時間復雜度內將 A[j] 放到下標為 i 的位置。

文字不如圖直觀，所以我畫了一張圖來展示分區的整個過程。

因為分區的過程涉及交換操作，如果數組中有兩個 8，其中一個是 pivot，經過分區處理之后，后面的 8 就有可能被放到了另一個 8 的前面，先后順序就顛倒了。所以，快速排序并不是一個穩定的排序算法。

到此，快速排序的原理你應該也掌握了。現在，我再來看另外一個問題：快排和歸并用的都是分治思想，遞推公式和遞歸代碼也非常相似，那它們的區別在哪里呢？

可以發現，歸并排序的處理過程是由下到上的，先處理子問題，然后再合并。而快排正好相反，它的處理過程是由上到下的，先分區，然后再處理子問題。歸并排序雖然是穩定的、時間復雜度為 O(nlogn) 的排序算法，但是它是非原地排序算法。我們前面講過，歸并之所以是非原地排序算法，主要原因是合并函數無法在原地執行。快速排序通過設計巧妙的原地分區函數，可以實現原地排序，解決了歸并排序占用太多內存的問題。

快速排序的性能分析

現在，我們來分析一下快速排序的性能。我在講解快排的實現原理的時候，已經分析了穩定性和空間復雜度。快排是一種原地、不穩定的排序算法。現在，我們集中精力來看快排的時間復雜度。

快排也是用遞歸來實現的。對于遞歸代碼的時間復雜度，我前面總結的公式，這里也還是適用的。如果每次分區操作，都能正好把數組分成大小接近相等的兩個小區間，那快排的時間復雜度遞推求解公式跟歸并是相同的。所以，快排的時間復雜度也是 O(nlogn)。

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

但是，公式成立的前提是每次分區操作，我們選擇的 pivot 都很合適，正好能將大區間對等地一分為二。但實際上這種情況是很難實現的。

我舉一個比較極端的例子。如果數組中的數據原來已經是有序的了，比如 1，3，5，6，8。如果我們每次選擇最后一個元素作為 pivot，那每次分區得到的兩個區間都是不均等的。我們需要進行大約 n 次分區操作，才能完成快排的整個過程。每次分區我們平均要掃描大約 n/2 個元素，這種情況下，快排的時間復雜度就從 O(nlogn) 退化成了 O(n2)。

我們剛剛講了兩個極端情況下的時間復雜度，一個是分區極其均衡，一個是分區極其不均衡。它們分別對應快排的最好情況時間復雜度和最壞情況時間復雜度。那快排的平均情況時間復雜度是多少呢？

我們假設每次分區操作都將區間分成大小為 9:1 的兩個小區間。我們繼續套用遞歸時間復雜度的遞推公式，就會變成這樣：

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

這個公式的遞推求解的過程非常復雜，雖然可以求解，但我不推薦用這種方法。實際上，遞歸的時間復雜度的求解方法除了遞推公式之外，還有遞歸樹，在樹那一節我再講，這里暫時不說。我這里直接給你結論：T(n) 在大部分情況下的時間復雜度都可以做到 O(nlogn)，只有在極端情況下，才會退化到 O(n2)。而且，我們也有很多方法將這個概率降到很低，如何來做？我們后面章節再講。

解答開篇
快排核心思想就是分治和分區，我們可以利用分區的思想，來解答開篇的問題：O(n) 時間復雜度內求無序數組中的第 K 大元素。比如，4， 2， 5， 12， 3 這樣一組數據，第 3 大元素就是 4。

我們選擇數組區間 A[0…n-1] 的最后一個元素 A[n-1] 作為 pivot，對數組 A[0…n-1] 原地分區，這樣數組就分成了三部分，A[0…p-1]、A[p]、A[p+1…n-1]。

如果 p+1=K，那 A[p] 就是要求解的元素；如果 K>p+1, 說明第 K 大元素出現在 A[p+1…n-1] 區間，我們再按照上面的思路遞歸地在 A[p+1…n-1] 這個區間內查找。同理，如果 K<p+1，那我們就在 A[0…p-1] 區間查找。

我們再來看，為什么上述解決思路的時間復雜度是 O(n)？

第一次分區查找，我們需要對大小為 n 的數組執行分區操作，需要遍歷 n 個元素。第二次分區查找，我們只需要對大小為 n/2 的數組執行分區操作，需要遍歷 n/2 個元素。依次類推，分區遍歷元素的個數分別為、n/2、n/4、n/8、n/16.……直到區間縮小為 1。

如果我們把每次分區遍歷的元素個數加起來，就是：n+n/2+n/4+n/8+…+1。這是一個等比數列求和，最后的和等于 2n-1。所以，上述解決思路的時間復雜度就為 O(n)。

你可能會說，我有個很笨的辦法，每次取數組中的最小值，將其移動到數組的最前面，然后在剩下的數組中繼續找最小值，以此類推，執行 K 次，找到的數據不就是第 K 大元素了嗎？

不過，時間復雜度就并不是 O(n) 了，而是 O(K * n)。你可能會說，時間復雜度前面的系數不是可以忽略嗎？O(K * n) 不就等于 O(n) 嗎？

這個可不能這么簡單地劃等號。當 K 是比較小的常量時，比如 1、2，那最好時間復雜度確實是 O(n)；但當 K 等于 n/2 或者 n 時，這種壞情下的況時間復雜度就是 O(n2) 了。

內容小結

歸并排序和快速排序是兩種稍微復雜的排序算法，它們用的都是分治的思想，代碼都通過遞歸來實現，過程非常相似。理解歸并排序的重點是理解遞推公式和 merge() 合并函數。同理，理解快排的重點也是理解遞推公式，還有 partition() 分區函數。

歸并排序算法是一種在任何情況下時間復雜度都比較穩定的排序算法，這也使它存在致命的缺點，即歸并排序不是原地排序算法，空間復雜度比較高，是 O(n)。正因為此，它也沒有快排應用廣泛。

快速排序算法雖然最壞情況下的時間復雜度是 O(n2)，但是平均情況下時間復雜度都是 O(nlogn)。不僅如此，快速排序算法時間復雜度退化到 O(n2) 的概率非常小，我們可以通過合理地選擇 pivot 來避免這種情況。

課后思考

現在你有 10 個接口訪問日志文件，每個日志文件大小約 300MB，每個文件里的日志都是按照時間戳從小到大排序的。你希望將這 10 個較小的日志文件，合并為 1 個日志文件，合并之后的日志仍然按照時間戳從小到大排列。如果處理上述排序任務的機器內存只有 1GB，你有什么好的解決思路，能“快速”地將這 10 個日志文件合并嗎？