到了 90 年代， Lee McMahon 為第七版 UNIX 寫的 quicksort 函式和其衍生版本已經流傳將近二十年之久。Bentley 和 McIlroy 發現，對所有他們能找到的 quicksort 實作，都可很容易地做個輸入讓它得花輸入長度平方的時間跑完。於是他們決定寫個更有效的 quicksort. 為了處理重複元素，他們又回頭研究了荷蘭國旗問題。

上次我們看了排序 [w,r,b,b,r,b,r,r,b,r,r,w,r,r] 的例子。Sr 和 Sb 兩種情況的交換分別用 和 表示。這個例子中，陣列有 14 個元素，而我們用了 13 次交換。

為什麼這麼慢呢？Bentley 和 McIlroy 認為問題出在我們花了太多工夫把兩個白色元素一步步挪到中間（也就是發生的情況）。與其如此，不如先把白色元素放到兩邊去，把陣列排成「白、紅、藍、白」。等排序完成，再把白色換回中間就可以了！他們用的不變量是這樣：

M ≤ w ≤ r ≤ u ≤ b ≤ N ∧ Pw1 ∧ Pr ∧ Pb ∧ Pw2

Pw1 ≡(∀i : M ≤ i < w : white(i))
Pr ≡ (∀i : w ≤ i < r : red(i))
Pb ≡ (∀i : u ≤ i < b : blue(i))
Pw2 ≡ (∀i : b ≤ i < N : white(i))

我用這不變量寫了一個程式：

  w, r, u, b := M, M, N, N
  { Inv: M ≤ w ≤ r ≤ u ≤ b ≤ N ∧ Pw1 ∧ Pr ∧ Pb ∧ Pw2, bound: b - w }
; do r < u →
    if red(r)             → r := r + 1
     | white(r)           → swap(w,r); w, r := w + 1, r + 1
     | blue(r) ∧ red(u-1) → swap(r,u-1); r, u := r + 1, u - 1
     | white(u-1)         → swap(u-1,b-1);  u, b := u - 1, b - 1
     | blue(u-1)          → u := u - 1
    fi
  od
  { M ≤ w ≤ r ≤ u ≤ b ≤ N ∧ Pw1 ∧ Pr ∧ Pb ∧ Pw2 ∧ r = u }

迴圈主體是對稱的五個情況，其中三種需要交換。以下是執行同一個輸入的結果：

確實不僅迴圈執行次數變少（由於 blue(r) ∧ red(u-1) 的情況可把灰色區域縮小兩個元素），交換次數也減少到了六次。當然，我們還需要兩次交換把白色元素放回中間。如果白色元素多，交換次數就多。但 Bentley 和 McIlroy 指出這部份的代價可分配到演算法其他部份去，因為白色元素一旦放到正確位置，便不用再被遞迴排序了。更詳盡的實驗結果可看他們的論文。

這兒的程式和 Bentley-McIlroy 的稍有不同。Bentley-McIlroy 用了兩個迴圈分別推進 r 與 u 的值。我個人比較喜歡這裡的做法，一來迴圈主體和不變量一樣對稱，二來這個程式非必須的限制較少：例如當 red(r) 與 blue(u-1) 都成立，在這裡可看出執行哪個指令對程式的正確性沒有影響。

只是，這麼一來，這迴圈解的好像不是荷蘭國旗問題了。有什麼國旗是「白、紅、藍、白」四色的呢？我找不出分出四條色塊的國旗。如果把顏色交換一下，倒是找到了右邊這幅 Rypin 的旗幟。Rypin 是波蘭的一個小鎮，根據 06 年的統計，人口約一萬六千人。

References

Jon L. Bentley, M. Douglas McIlroy. Engineering a sort function. Software—Practice & Experience 23(11), pp. 1249 - 1265. Nov. 1993.

Justin Peel. Has anyone seen this improvement to quicksort before? Stack Overflow , Jan 20, 2010.

答案是：用兩者都寫得出可運作的程式，但後者好寫得多。原因是：未知區段是我們的工作區，而我們有三種顏色要搬來搬去，把未知區段放在旁邊會使得某些搬移相當不便。

因此以下我們用第二個不變量，寫成邏輯式子是這樣的：

M ≤ r ≤ w ≤ b ≤ N ∧
(∀i : M ≤ i < r : red(i)) ∧
(∀i : r ≤ i < w : white(i)) ∧
(∀i : b ≤ i < N : blue(i))

最初若把 r, w, b 設為 M, M, N，不變量自然成立 --- M ≤ i < r, r ≤ i < w, 和 b ≤ i < N 三個區段都是空的，整個陣列都視為灰色的未知區。接下來我們希望在一個迴圈中逐漸縮小 w 和 b 的差距。當 w = b 時，陣列就照我們想要的顏色順序排好了。

迴圈中應該作什麼呢？既然目標是把 b - w 變小，關鍵的元素可能是 a[w] 和 a[b-1]. 也許我們可以先看看 a[w] 是紅、白、或藍色，分三種情況處理：或著我們也可檢查 a[b-1] 的顏色。個中優劣只有試過才知道了。依後見之明，我們發現先檢查 a[w] 較好。另一種選擇待會兒再談。

所以，程式架構大約是這樣：

   r, w, b, := M, M, N
   { Inv: M ≤ r ≤ w ≤ b ≤ N ∧ Pr ∧ Pw ∧ Pb, bound: b - w }
 ; do w < b →
     if red(w)   → Sr
      | white(w) → Sw
      | blue(w)  → Sb
     fi
   od
   { M ≤ r ≤ w ≤ b ≤ N ∧ Pr ∧ Pw ∧ Pb ∧ b = w }

其中 Pr, Pw, 和 Pb 分別是關於三個顏色之條件的簡寫：

Pr ≡ (∀i : M ≤ i < r : red(i))
Pw ≡ (∀i : r ≤ i < w : white(i))
Pb ≡ (∀i : b ≤ i < N : blue(i))

我們還需找出 Sr, Sw, 和 Sb 分別該是什麼。

white(w) 的情形最簡單：把 w 遞增之後不變量仍然滿足。Sw 可以是 w := w + 1.

blue(w) 的情況呢？若把 a[w] 和 a[b] 交換，我們可把 b 遞減，不變量也剛好滿足。Sb 可以是 swap(b,w); b := b - 1.

最複雜的是 red(w) 的情況。我們可把紅元素換到後面去，但之後為了滿足不變量，我們得把 r 和 w 都遞增。

總結下來，我們的程式是：

  r, w, b, := M, M, N
  { Inv: M ≤ r ≤ w ≤ b ≤ N ∧ Pr ∧ Pw ∧ Pb, bound: b - w }
; do w < b →
    if red(w)   → swap(r,w);  r, w := r + 1, w + 1
     | white(w) → w := w + 1
     | blue(w)  → swap(b,w);  b := b - 1
    fi
  od
  { M ≤ r ≤ w ≤ b ≤ N ∧ Pr ∧ Pw ∧ Pb ∧ b = w }

然而，上面的圖片其實遺漏了許多情況。例如，在 red(w) 的情形中，如果 b = w ，程式還會對嗎？我們得切記畫圖僅可幫助理解，程式的推導驗證還是得回到形式系統來作。

以 red(w) 的情況為例，我們得證明：

  { M ≤ r ≤ w < b ≤ N ∧ Pr ∧ Pw ∧ Pb ∧ red(w) }
  swap(r,w)
  { (M ≤ r ≤ w ≤ b ≤ N ∧ Pr ∧ Pw ∧ Pb)[r, w := r + 1, w + 1] }
; r, w := r + 1, w + 1
  { M ≤ r ≤ w ≤ b ≤ N ∧ Pr ∧ Pw ∧ Pb }

據我所知，在國內只有 FLOLAC 程式建構課教過這種證明（如果你會的話，來認識一下吧！），所以除非有人要求，這裡就只透露我們得分出 r = w 和 r < w 的兩種情形，不深入談細節了。

這是一個 O(N-M) 的程式。如果三色數量相同，我們平均需要大約 2(N-M)/3 次交換。如果我們當初選擇從檢查 a[b-1] 開始，也可做出一個稍微不同的程式，但平均需要的交換次數增加到 N-M 次。

下圖是排序 [w,r,b,b,r,b,r,r,b,r,r,w,r,r] 的例子。Sr 和 Sb 兩種情況的交換分別用 和 表示。這個例子中，陣列有 14 個元素，而我們用了 13 次交換。

這個「荷蘭國旗問題」由 Feijen 和 Dijkstra 提出 — 紅白藍是荷蘭國旗的顏色。（為何不是法國國旗？恐怕因為 Feijen 和 Dijkstra 都是荷蘭人吧？）對演算法熟悉的朋友可能知道這可在 quicksort 中作分割用：選定一個元素當 pivot, 紅、白、藍三色分別代表小於、等於、和大於 pivot 的元素。和傳統將陣列分割成兩塊的做法比較，這種「三向」分割法不僅可能把陣列切得較小，也便於處理陣列中的重複元素。然而，Sedgewick 和 Wayne 的上課資料 (1, 2)提到，直到 90 年代中，大家仍認為三向分割法效率差，不值得做。直到 Bentley 與 McIlroy 提出了更快的三向分割法，Sedgewick 和 Bentley 也證明了此種 quicksort 是熵值最佳解 — 每元素平均被比較數在熵值的常數比率之內，三向分割法終於漸漸被用在包括 Java 與 C 的函式庫中。

九月的 IFIP Working Group 2.1 會議中，Wouter Swierstra 示範如何在 Agda 中證明此程序能正常終止，引起了一些相關討論。我才因此聽 Peter Pepper 說到，Dijkstra 當初研究這問題倒不是基於效率考量，而是他認為分割成兩份的傳統 quicksort 的終止證明不漂亮。Dijkstra 希望採用三向分割法後能更容易表達紅（小於 pivot）和藍色（大於 pivot）的區塊絕對比原陣列短的性質。然而，在 Peter 的印象中 Dijkstra 從沒把這層考量寫下來。「我們如果不告訴學生，以後就沒人知道了呢！」他說。

解一個問題前總得先看看如何精確描述我們要什麼。初始條件是 M ≤ N, 以及每個元素的顏色只可能是紅白藍之一：

M ≤ N ∧ (∀i : M ≤ i < N : red(i) ∨ white (i) ∨ blue(i))

而在程式結束時，我們希望找到 r 和 w 兩值, 滿足：

M ≤ r ≤ w ≤ N ∧
(∀i : M ≤ i < r : red(i)) ∧                                  (*)
(∀i : r ≤ i < w : white(i)) ∧
(∀i : w ≤ i < N : blue(i))

注意在此我們用 Dijkstra 常使用的方法，以一對變數 x, y 表示 a[x], a[x+1] .. a[y-1] 這個區段（較正式的寫法是 a[x..y) -- 左合右開）。一個區段 a[x..y) 的元素數目剛好是 y-x, 而當 x = y 時該區段是空的。前面的規格涵括了輸入為空陣列的可能性（M = N），也允許某些顏色沒有元素（如 r = w 時，輸出陣列沒有白色的元素）。

這種程式至少得用個迴圈，而既然有迴圈，我們得為它找個不變量。通常的作法是把 (*) 擴充。我們也可猜到程式執行中必定有一段「未知」的區段。一個可能性是允許這個未知區段出現在右邊：

或著，我們也可能允許這段未知區段出現在白色與藍色之間：

剩下兩種情形則分別與前兩種對稱，因此我們只需考慮前兩者即可。

圖片可以幫助理解，但真正的理解仍得靠形式化的描述。第一種情形可描述為:

M ≤ r ≤ w ≤ b ≤ N ∧
(∀i : M ≤ i < r : red(i)) ∧
(∀i : r ≤ i < w : white(i)) ∧
(∀i : w ≤ i < b : blue(i))

那麼我們可採用的策略就是最初讓 r,w,b := M,M,M，每次在迴圈中試著遞增 b, 當 b = N, (*) 就成立了。

若選擇第二種可能，形式化的描述是:

M ≤ r ≤ w ≤ b ≤ N ∧
(∀i : M ≤ i < r : red(i)) ∧
(∀i : r ≤ i < w : white(i)) ∧
(∀i : b ≤ i < N : blue(i))

三個變數可先設為 r,w,b := M,M,N, 如果 b = w, (*) 便能成立。

哪個不變量比較好用呢？讀者不妨試試看。我們下回分解。

|[ con N {N ≥ 2}; a : array [0..N) of int;
   var r : int;
   S
   { r = (Σ i,j : 0 ≤ i < j < N : (a.i - a.j)²) }
]|

用口語說：給定一個有兩個以上元素的陣列a, 計算任兩個元素前者減後者所得之差的平方的總和（這裡依照 guarded command language 的傳統把 a 的第 i 個元素寫成 a.i；函數取值 f(x) 也寫成 f.x）。

大家大概都能寫出一個使用兩層迴圈的程式。蠻可惜地，發現這題其實能只用一個迴圈、在線性時間內做完的則不多，因此我想可在這討論一下。

量詞 (Quantifiers)

先回顧一下關於量詞 (quantifiers) 的規則。給定一個滿足交換律、結合律、有單位元素 e 的二元運算元 ⊕。若將所有在區段 [A .. B) 之間的值非正式地寫成 i₀, i₁, i₂ ... in，那麼 F.i₀ ⊕ F.i₁ ⊕ F.i₂ ⊕ ... ⊕ F.in 就表示成：

   (⊕ i : A ≤ i < B : F.i)

更一般地說，若所有滿足 R 的值是 i₀, i₁, i₂ ... in，這個式子

   (⊕ i : R.i : F.i)

表示的就是F.i₀ ⊕ F.i₁ ⊕ F.i₂ ⊕ ... ⊕ F.in. 當確定不會混淆時，我們可把 R.i 與 F.i 中的 i 省略。

關於量詞的規則有

1. (⊕ i : false : F.i) = e
2. (⊕ i : i = x : F.i) = F.x
3. (⊕ i : R : F) ⊕ (⊕ i : S : F) = (⊕ i : R ∨ S : F) ⊕ (⊕ i : R ∧ S : F)
4. (⊕ i : R : F) ⊕ (⊕ i : R : G) = (⊕ : R : F ⊕ G)
5. (⊕ i : R.i : (⊕ j : S.j : F.i.j)) = (⊕ j : S.j : (⊕ i : R.i : F.i.j))

常用的「分出第n項」是規則 1 和 3 的結果：若已知 n > 0, 我們可把區段 0 ≤ i < n + 1 分為無交集的兩塊 -- 0 ≤ i < n 和 i = n。由規則 3 （左右反轉後）和 1 我們得到：

  (⊕ i : 0 ≤ i < n + 1 : F.i) = (⊕ i : 0 ≤ i < n : F.i) ⊕ F.n

兩個變數的量詞可用一個變數的量詞定義:

   (⊕ i,j : R.i ∧ S.i,j : F.i.j) = (⊕ i : R.i : (⊕ j : S.i.j : F.i.j))

如果 ⊗ 可分配到 ⊕ 中，我們另有這項性質：

   x ⊗ (⊕ i : R : F) = (⊗ i : R : x ⊗ F)

習慣上我們常把 (+ i : R : F) 寫成 (Σ i : R : F).

計算平方和

大家都可猜到第一步是把常數 N 換成變數 n。整個程式會是一個迴圈，我們在不變量中試著維持這樣的關係：

   P  ≣  r = (Σ i,j : 0 ≤ i < j < n : (a.i - a.j)²)

接下來，我們猜想程式中大概會用這樣一個迴圈，每次把 n 遞增，直到 n 與 N 相碰為止：

   { Inv: P ∧ 2 ≤ n ≤ N , Bound: N - n}
   do n ≠ N → ... ; n := n + 1 od

那麼現在要討論的就是如何在 n := n + 1 之前更新 r 的值，使得不變量 P 仍能滿足了。

假設 P 與 2 ≤ n ≤ N 成立，我們把 r 的值之中的 n 代換成 n + 1 試試看：

   (Σ i,j : 0 ≤ i < j < n : (a.i - a.j)²)[n+1 / n]
 = (Σ i,j : 0 ≤ i < j < n + 1 : (a.i - a.j)²)
 =   { split off j = n }
   (Σ i,j : 0 ≤ i < j < n : (a.i - a.j)²) +
   (Σ i : 0 ≤ i < n : (a.i - a.n)²)
 =   { P }
   r + (Σ i : 0 ≤ i < n : (a.i - a.n)²)

大部分人推導至此，會想用一個內層迴圈算 (Σ i,j : 0 ≤ i < n : (a.i - a.n)²). 但細看這樣寫出的程式，會發現許多計算是重複的。確實，這個式子還可以再拆：

   r + (Σ i : 0 ≤ i < n : (a.i - a.n)²)
 =   { (x - y)² = x² - 2xy + y² }
   r + (Σ i : 0 ≤ i < n : a.i² - 2 × a.i × a.n + a.n²)
 =   { 規則 4 }
   r + (Σ i : 0 ≤ i < n : a.i²)
     - (Σ i : 0 ≤ i < n : 2 × a.i × a.n)
     + (Σ i : 0 ≤ i < n : a.n²)
 =   { a.n 已是常數，乘法與加法之分配律 }
   r + (Σ i : 0 ≤ i < n : a.i²)
     - 2 × (Σ i : 0 ≤ i < n : a.i) × a.n
     + (Σ i : 0 ≤ i < n : a.n²)
 =   { 化簡最後一項 }
   r + (Σ i : 0 ≤ i < n : a.i²)
     - 2 × (Σ i : 0 ≤ i < n : a.i) × a.n + n × a.n²

所以我們可另用兩個變數分別儲存 (Σ i : 0 ≤ i < n : a.i²) 和 (Σ i : 0 ≤ i < n : a.i) 的值：

  Q₀  ≣  s = (Σ i : 0 ≤ i < n : a.i²)
  Q₁  ≣  t = (Σ i : 0 ≤ i < n : a.i)

s 和 t 兩個變數的更新方式則不難推導出來。最後得到的程式如下：

|[ con N {N ≥ 2}; a : array [0..N) of int;
   var r, s, t, n : int;

   r, s, t, n := (a.0 - a.1)², a.0² + a.1², a.0 + a.1, 2
   { Inv: P ∧ Q₀ ∧ Q₁ ∧ 2 ≤ n ≤ N , Bound: N - n }
 ; do n ≠ N →
      r := r + s - 2 × t × a.n + n × a.n²;
      s := s + a.n²;
      t := t + a.n;
      n := n + 1
   od
   { r = (Σ i,j : 0 ≤ i < j < N : (a.i - a.j)²) }
]|

其他解答

大部分（有寫出答案的）同學寫的是兩層迴圈，O(N²) 的程式。少部份導出了上述的 O(N) 程式（很棒唷！）。另有一位同學給了個我沒想到的解：

|[ con N {N ≥ 2}; a : array [0..N) of int;
   var r, i, j : int;

   r, i, j := 0, 0, 0
   { Inv: ... ∧ 0 ≤ i ≤ j ∧ 0 ≤ j ≤ N, Bound: ? }
 ; do j ≠ N →
       if i < j → r := r + (a.i - a.j)²;  i := i + 1
        | i = j → i, j := 0, j + 1
       fi
   od
]|

這仍是一個 O(N²) 的程式，基本上是把兩層 loop 的內層用手動的方式做。但我蠻想看看它的證明。可惜那位同學的程式、給的不變量、和 bound 都有些小瑕疵（可能時間真的不夠吧）。大家想試著證明看看嗎？

第一個念頭是用這個 Φ:

Φ(i,j) = a[i] ≤ K < a[j]

並令 M = 0。演算法結束後，Φ(l,l+1) = a[l] ≤ K < a[l+1] 一定成立，只要再看看 a[l] 是否等於 K 就可以了。但問題來了：van Gasteren-Feijen 演算法正確的兩個先決條件之一是 M < N -- van Gasteren-Feijen 演算法的迴圈設計便假設 [M,N) 這個區段不是空的，因此我們無法處理空陣列。其次是 Φ(0,N) 得要成立，但 a[0] ≤ K < a[N] 並不一定成立呢。

我們可以把上述的例外都分開測試。但 van Gasteren 與 Feijen 建議的作法是在陣列頭尾各補一個想像元素：a[-1] 小於任何數，a[N] 大於任何數。一個等價的說法是用這個Φ:

Φ(i,j)  =  (i = -1  ∨  a[i] ≤ K)  ∧  (K < a[j]  ∨  j = N)

最初令 l, r := -1, N, 那麼初始條件就滿足了。程式如下：

  { 0 ≤ N ∧ Φ(-1,N) }
  l, r := -1, N
  { Inv: -1 ≤ l < r ≤ N  ∧  Φ(l,r),   Bound: r - l }
; do l+1 ≠ r →
    { l + 2 < r }
    m := (l + r) / 2
  ; if a[m] ≤ K → l := m
    [] K < a[m] → r := m
    fi
  od
  { -1 ≤ l < N  ∧  Φ(l,l+1) }
; if l > -1 → found := a[l] = K
  [] l = -1 → found := false
  fi

如果在陣列頭尾補元素讓你覺得很不妥，別擔心。迴圈不變量保證了 -1 < m < N，因此從頭到尾，a[-1] 和 a[N] 兩個位置都沒被讀過 -- 陣列 a 並不用真正有什麼改變，兩個想像元素只是為了證明演算法正確而假想出來的。這也讓我們可以處理空陣列了。我覺得這是 van Gasteren-Feijen 演算法漂亮之處。

Bentley 的程式

Jon Bentley 在 Programming Pearls 一書中給的二元搜尋法程式如果翻譯成 guarded command language, 並把陣列索引從 [1..N] 改成 [0..N-1], 大約是這樣：

  l, r := 0, N-1
; do l ≤ r →
    m := (l + r) / 2
  ; if a[m] < K → l := m + 1
    [] a[m] = K → found := true; break
    [] K < a[m] → r := m - 1
    fi
  od
; found := false

Bentley 書中也有以口語描述的正確性證明。我原想在課堂上講解這個程式，畢竟這個版本流傳較廣 -- 許多函式庫裡的二元搜尋法程式就是這麼寫的。但困難之一是若要把 K < a[m] 和 r := m - 1 牽上關係，似乎非得提早用上陣列已排序好的性質。這個演算法便比較難在更廣泛的脈絡中解釋了。當然，另一個困難是我不知如何在 Hoare logic 中簡單地解釋 break。

乍看之下我以為 Bentley 演算法的搜尋範圍縮小得比 van Gasteren-Feijen 快：l 和 r 分別設為 m+1 與 m-1，並不是 m. 細看之後又發現並不盡然。變數 l 可設為 m+1, 因為 m 的位置已由另一個比較 a[m] = K 處理；變數 r 設為 m-1，則可能僅因為 Bentley 將陣列區段用 a[l..r-1] 表示，而 van Gasteren-Feijen 演算法把同一個區段表達為 a[l..r).

Bentley 與 van Gasteren-Feijen 演算法解的是問題並不完全相同。當 K 在陣列中出現一次以上，Bentley 演算法不限定傳回哪個，van Gasteren-Feijen 則必定傳回索引最大的那個。當 K 不在陣列中時，van Gasteren-Feijen 演算法似乎較快，因為兩者都得跑完，而 van Gasteren-Feijen 的迴圈中只有一個比較（最後一個比較可省去）。Bentley 演算法若提早發現 K 可隨時跳出迴圈，代價是迴圈中多了一個比較。當陣列中確實找得到 K, 這樣的交換是否值得呢？Timothy J. Rolfe 的實驗似乎認為只用一個比較的演算法平均上仍快一些。

習題

Van Gasteren 與 Feijen 建議的幾個習題中包括這個：假設陣列 a[0..N) 是一串嚴格遞增的數字緊接著一串嚴格遞減的數字，試用二元搜尋法找到陣列中的最大值。本問題中我覺得合理的假設是遞增和遞減數列均可能為空的，但 a 至少有一個元素：

0 < N ⋀
(∃ M: 0 ≤ M < N :
  (∀ i,j : 0 ≤ i < j ≤ M : a[i] < a[j]) ⋀
  (∀ i,j : M ≤ i < j < N : a[i] > a[j]))

這剛好是「最大密度區段」問題的演算法之一需要的一個副程式。我記得當時也是先隨便寫寫，幾次寫不對才發現真是難。現在總算是知道一點理論背景，覺得安心多了。你要試試看嗎？

中間索引怎麼取？

關於中間值 m := (l+r)/2, 後來另有些其他故事。Google 的 Joshua Bloch 發現當陣列夠大時，l 和 r 相加可能造成溢位。他可不是故意挑毛病，這個 "bug" 是 Sun 抓到的。他建議該這麼寫：

int m = l + ((r - l) / 2);                          /* for Java/C/C++ */
int m = (l + r) >>> 1;                              /* for Java */
m = ((unsigned int)l + (unsigned int)r)) >> 1;      /* for C/C++ */

Bloch 的發現自然引起了不少討論。有人認為這是整數型別的問題，而不是二元搜尋法的 bug. 有人質疑，討論 int 無法索引的陣列是否有意義？接下來可能一路談到組合語言定址法上頭。有人說，要造成索引溢位，陣列得有 4GB 大，你這輩子在 4GB 的陣列中作二元搜尋過嗎？有人便答，人家可是 Google 來的。Google 的陣列比常人的大上幾倍也不是不可能的唷。

如果往抽象的極端走，Roland Backhouse 在 Program Construction: Calculating Implementations from Specifications 書中則建議應該用 m := (l + r - 1) / 2 -- 如此一來不管該語言的整數除法到底是無條件消去、四捨五入、或是無條件進入，算出來的 m 值都會是 ⌊(l + r)/2⌋.

參考資料

• Roland Backhouse. Program Construction: Calculating Implementations from Specifications. John Wiley and Sons, 2003.
• Jon Bentley. Programming Pearls, Second Edition. Addison-Wesley, 2000.
• Joshua Bloch. Extra, Extra - Read All About It: Nearly All Binary Searches and Mergesorts are Broken. Google Research Blog, June 02, 2006.
• Netty van Gasteren and Wim Feijen. The binary search revisited. AvG127/WF214, 1995.
• Timothy J. Rolfe. Analytic derivation of comparisons in binary search. SIGNUM Newsletter, Vol. 32, No. 4 (Oct 1997), pp. 15-19.

最近為了今夏的 FLOLAC 研習營開始找些資料。為了教些離開研習營後仍有用的東西，今年我想教 Hoare 邏輯與 Dijkstra 使用最弱前提(weakest precondition) 的程式建構法。對想寫好程式的人來說，這應是基礎知識，但大家對這些題目卻陌生得令人驚訝。

二元搜尋似乎是個該談到的例子：給一個排序好、長度為 N 的陣列，在 O(log N) 的時間內決定其中是否有某個值。資訊系學生在演算法課上一定學過二元搜尋。身經百戰的程式員寫個二元搜尋程式應該也不是難事吧？然而 Jon Bentley 在他有名的 Programming Pearls 一書中卻提到只有大約一成的專業程式員能第一次把這程式寫對。這一定要親身試試看才會相信。我抱著警覺心試了一次，寫了一個應該正確（畢竟我對這套方法算是比較熟了），但不怎麼漂亮的程式。請朋友寫寫看，也果然出現了一些常見的 bug. 看來這確實是個程式設計課堂上該講的好例子。

迴圈、不變量、與界限

Van Gasteren 和 Feijen 在一篇 1995 年的研究筆記中釐清了大家常有的一個迷思：你認為你對二元搜尋很了解嗎？那您可知道，二元搜尋其實並不一定要用在排序好的陣列上？事實上，他們認為總是把二元搜尋類比為翻字典找字，反倒造成了一個教學盲點。

Van Gasteren 和 Feijen 先試解一個更廣的問題：給定整數 M 和 N, 和一個接受兩個整數參數的布林函數 Φ，已知 M < N，並知 Φ(M,N) 成立。Φ 另需滿足一些條件，待會兒再談。試寫一個程式，找兩個介於 M 和 N 之間、滿足 Φ 的相鄰整數。若寫成邏輯式子，程式執行完畢後需滿足：

M ≤ l < N   ∧   Φ(l,l+1)

這是 Van Gasteren 和 Feijen 的程式：

  { M < N ∧ Φ(M,N) }
  l, r := M, N
  { Inv: M ≤ l < r ≤ N  ∧  Φ(l,r),   Bound: r - l }
; do l+1 ≠ r →
    { l + 2 < r }
    m := (l + r) / 2
  ; if Φ(m,r) → l := m
    [] Φ(l,m) → r := m
    fi
  od
  { M ≤ l < N  ∧  Φ(l,l+1) }

這裡的虛擬碼使用的是 Dijkstra 的 Guarded Command Language。多個變數可同時設值（如 l, r := M, N），do 相當於 while 迴圈。條件判斷 if 和一般程式語言不同之處是若不只一個條件成立，程式可任選一個分支執行。註解依照 Algol 系語言的傳統用大括號，但此處我們也把註解視作斷言 (assertion), 表示程式執行到此處一定會成立的條件。這是給人看的資訊，也是我們藉以證明程式正確的重要線索。

證明迴圈正確性的兩大關鍵是其不變量 (loop invariant)和界限 (bound)。本程式只有一個迴圈，不變量和界限註記在這一行:

{ Inv: M ≤ l < r ≤ N  ∧  Φ(l,r),   Bound: r - l }

「不變量」事實上並不是一個「量」，而是程式每次執行到迴圈進入點前必定會滿足的條件。此處不變量為 M ≤ l < r ≤ N 和 Φ(l,r)。變數 l 和 r 的初始值分別是 M 和 N. 依照假設，M = l < r = N 和 Φ(l,r) = Φ(M,N) 確實成立。因此第一次執行到迴圈之前，不變量確實是滿足的。

迴圈的進入條件是 l+1 ≠ r，和不變量中的 l < r 合起來看，意思是 l 和 r 不是相鄰的整數。因此m := (l + r) / 2 執行後，m 必定在 l 和 r 之間，但不等於 l 和 r。接下來的 if 敘述中，變數 l 會被設成 m 的先決條件是 Φ(m,r)，變數 r 會被設成 m 的先決條件是 Φ(l,m)。不論是哪種情形，執行完 if 敘述後，Φ(l,r) 一定還是成立。所以再回到迴圈開頭時，不變量仍被滿足。

長此以往，直到有一天剛好 l+1 ≠ r 不成立了，也就是說 l 和 r 已是相鄰的整數，和不變量合起來看，剛好我們要的 結束條件 M ≤ l < N ∧ Φ(l,l+1) 就被滿足了！

只是還有兩個但書：首先，if 敘述中的 Φ(m,r) 和 Φ(l,m) 這兩個條件至少要有一個成立。這是 Φ 的另一個要求：

 Φ(l,r)  ∧  l < m < r   ⇒   Φ(l,m)  ∨  Φ(m,r)(*)

其次，我們怎知道迴圈會有停下來的一天呢？這就是「界限」 r-l 處理的部份。由於 M < N, 我們知道 r-l 最初會是一個正整數。而如前所述，每次進入迴圈後，m 的值必定在 l 和 r 之間，但不等於 l 和 r。因此迴圈每執行一次，r-l 就變小一些。當 r-l 等於一時，迴圈就得停了。因此我們知道這迴圈不可能永遠執行下去。

以上便是該程式正確的大略證明。我們只是用中文說說，更仔細的證明是應該要有些數學演算的。關於什麼算是證明、為何要有「形式」證明，希望以後有機會寫寫看。

有哪些函數 Φ 滿足條件 (*) 呢？ Van Gasteren 與 Feijen 舉的例子包括:

• Φ(i,j) = a[i] ≠ a[j]，此處 a[M..N] 是某陣列。程式會幫我們找到兩個相鄰但不相等的元素。Van Gasteren 與 Feijen 認為這個特例可能是解說二元搜尋比較合適的例子。
• Φ(i,j) = a[i] × a[j] ≤ 0, 程式將找到兩個相鄰但正負號不相等，或至少有一個為零的元素。
• Φ(i,j) = a[i] < a[j],
• Φ(i,j) = a[i] ∨ a[j], 等等。

再回到最初的問題：怎麼在排序好的陣列中找某個關鍵值呢？理想上我們希望設計某個 Φ，然後套用上面的程式。先賣個關子，下回分解。

參考資料

• Roland Backhouse. Program Construction: Calculating Implementations from Specifications. John Wiley and Sons, 2003.
• Jon Bentley. Programming Pearls, Second Edition. Addison-Wesley, 2000.
• Joshua Bloch. Extra, Extra - Read All About It: Nearly All Binary Searches and Mergesorts are Broken. Google Research Blog, June 02, 2006.
• Netty van Gasteren and Wim Feijen. The binary search revisited. AvG127/WF214, 1995.
• Timothy J. Rolfe. Analytic derivation of comparisons in binary search. SIGNUM Newsletter, Vol. 32, No. 4 (Oct 1997), pp. 15-19.

1960-68 年間，Hoare 仍在業界工作，帶領一個實作 ALGOL 60 編譯器的團隊。ALGOL 的語法用 context-free language 定義得相當精簡優雅，語意卻仍以非形式的方式定義。Hoare 希望有個方式能一方面嚴格描述 ALGOL 的語意，一方面又不限制到編譯器製作者使用各種最佳化方法的自由。這是 Hoare 邏輯的由來。

Hoare 漸漸發現這題目大概可以研究一輩子。而且大概直到他退休，這東西也不會在業界得到廣泛應用。這使他在 1968 年從業界進入學界，而到他 1999 年退休為止，看來這兩個預測都蠻準確的。

令他意外的事情呢？Hoare 說他可以預期程式會越來越大，測試這種大程式也會越來越困難。他沒想到的是測試不僅是用在程式上，更是對人的考驗。通過這種考驗的工程師所培養出的直覺和經驗也是讓軟體可靠的重要因素。形式方法應該去支持程式員的直覺判斷，而非壓抑它。況且開發中的軟體若在測試中表現得很差，剛好可讓開發部門作為說服管理部門延長開發時間的依據。

把測試和證明對立起來的看法也許是個基本錯誤 — 工程師本來就要使用各種有用的工具。形式方法能做的貢獻是盡量提供更好的工具。在他退休並加入微軟劍橋研究中心後，他驚訝地發現 Hoare 邏輯斷言並不是用來證明程式正確性，而是用在測試並發現錯誤上。形式方法在除錯上的應用反倒比證明來得早。

Hoare 的邏輯斷言使用的是標準的邏輯與離散數學。我想後來許多程式語言學者的想法也是盡量設計符合數學模型的程式語言。Hoare 卻說近年來的發展剛好相反：許多數學概念為了分析程式語言的新功能（如物件、classes, heap, 指標等）而發展出來；大家開發新種類的代數，用來描述分散系統、並行系統等等。新的邏輯，如線性邏輯、分離邏輯等為了分析程式的行為而發明，有些還在其他的領域，如計算生物學、基因學、甚至社會學派上用場。

學者們一度相信要等到軟體錯誤造成了大災害，大家才會了解形式方法與軟體驗證的重要。事實卻不然。1996 年 Ariane V 火箭測試發射因軟體故障而失敗後，管理階層的策略是跑更多更嚴密的測試。越嚇他們，他們越會抱緊熟悉的方法不放。對軟體驗證的興趣反倒是從利潤出發：有效地使用形式方法會比較省錢。

而使軟體驗證流行的助力卻來自大家都沒想到的地方：駭客們。駭客攻擊造成大量的金錢損失，而駭客使用的軟體漏洞通常無法經由測試找到。唯一的可能是自動分析並驗證程式碼。這使得資訊安全成為軟體驗證的一大賣點，也由此漸漸推廣到汽車、電子產品、和航太產業中。

Hoare 接著談到業界與學界的不同使命。業界自然是使用最成熟的技術、解決最容易而迫切的問題。但學界的天職是完全相反的：建構最泛用的理論、解釋最多的現象、尋求可長可久的知識。不論哪種科學研究都嘗試回答這一系列的問題：這個東西做什麼？怎麼運作？為什麼能這麼運作？而有什麼證據顯示我們提出的答案是對的？在電腦科學中我們已經大致知道怎麼回答這些問題。一個程式的規格告訴我們它做什麼，斷言和其他內部模組、界面間的約定告訴我們他怎麼運作，程式語言語意解釋它為什麼能這麼運作，數學與邏輯證明增強我們的信心，而現在這些證明可以用電腦和工具產生和檢查。現在電腦科學家的舞台與使命是從事有說服力的實驗，檢驗這些工具和理論是否足以涵蓋今日大部分的程式、設計模式、語言、和應用。「實驗」在此的意義可能是現有應用程式的重新設計，從這些實驗得到的經驗將繼續推動理論與工具的進步。