修訂調車場算法

book/零．二版/再遇剖析.md

@@ -47,7 +47,7 @@
 
 ### 決定優先級的算法
 
-道友們可能在煉氣時就學過或自己想到過該如何巧用棧，從左到右掃過一個算式就能求其值。該算法名為[調車場算法](https://en.wikipedia.org/wiki/Shunting_yard_algorithm)，而其遞迴版本（遞迴跟棧關係密切啊！）有另一個名字，叫[優先級爬升算法](https://en.wikipedia.org/wiki/Operator-precedence_parser)。
+道友們可能在煉氣時就學過或自己想到過該如何巧用棧，從左到右掃過一個算式求其值。該算法名為[調車場算法](https://en.wikipedia.org/wiki/Shunting_yard_algorithm)，而其遞迴版本（遞迴跟棧關係密切啊！）有另一個名字，叫[優先級爬升算法](https://en.wikipedia.org/wiki/Operator-precedence_parser)。
 
 算法並不難，首先來觀察一個算式
 ```c
@@ -69,7 +69,7 @@
 ```c
 1 == 5 - 3 % 2 * 4
 ```
-時，都無法確定任何一個算子結合，注意到，無法結合是因為，**至今遇到的所有算子中右側總是比左側優先級高，故始終無法結合**。（遇到這種右側總比左側高的結構，往往意味這能用棧來解題。）
+時，都無法確定任何一個算子結合，注意到，無法結合是因為，**至今遇到的所有算子中，新算子總是比舊算子優先級高**。（發現維護的序列具有單調特徵時，往往意味能用棧來解題。）
 
 但再往右讀取一個算子就不一樣了
 ```c
@@ -90,41 +90,27 @@ x 兩側的 - 優先級相等，但 - 是左結合，優先往左側結合，故
 此時 - 的優先級大於 == ，如果右側還有算子的話，倒是無法確定 x - 1 會結合，但現在右側已經沒東西了，故 x - 1 結合，最後輪到 == 。
 
 用虛擬碼來表述該過程：
-```
-每讀取一個新算子，拿其與當下算式最右側的算子做比較
 
-若新算子優先級較低：
-    則最右側算子可結合，此時再與結合後算式中的最右側算子比較。
-若新算子優先級較高：
-    無法確定優先級，將新算子丟入算式
+```虛擬
+想像吾人先蓋住整個算式，再從左到右慢慢展露整個算式。
+
+持續向右讀取新算子：
+    將新算子與已知算式最右側的算子做比較
+    若新算子優先級較低：
+        則最右側已知算子可結合，此時再與結合後算式中的最右側算子比較。
+        重複此動作直到已知算子優先級低於新算子，此時沒有一個算子的優先級能確認，將新算子丟回已知算式
+    若新算子優先級較高：
+        沒有一個算子的優先級能確認，將新算子丟進已知算式
 
 當算子讀取完畢，從右往左結合。
 ```
 該算法稍作加強，也能處理括號，基本想法是每當遇到右括號時，就當做算子已經暫時讀取完畢，算子算式由右一直向左結合直到碰到左括號。
 
-#### 以棧表示該過程
-此過程能以棧輕易模擬，具體作法請見下方範例。
-
-#### 遞迴做法
-TODO:
-
-
-### 混用回溯剖析與優先級爬升
-
-那吾人不妨在剖析器中將算子、算元與括號順序保留，再由此優先級爬升算法來處理優先級。
-
-```語法
-算式      = 原子式・(算子・原子式)*
-
-原子式    = 數字
-         | 變數
-         | "（"・算式・"）"
-```
-
-由於括號已經由原子式處理，在剖析算式中不需要處理括號，應用前述的簡單優先級處理算法即可。
+#### 以棧實作：調車場算法
+此過程能以棧輕易模擬，具體作法可參照下方源碼：
 
 ```rust
-fn 優先級(運算子: Ｏ運算子) -> u64 {
+fn 優先級(運算子: &Ｏ運算子) -> u64 {
     match 運算子 {
         Ｏ運算子::乘 => 4,
         Ｏ運算子::除 => 4,
@@ -142,54 +128,86 @@ fn 優先級(運算子: Ｏ運算子) -> u64 {
         Ｏ運算子::大於等於 => 1,
     }
 }
-fn 剖析算式(&self, 游標: usize) -> Option<(Ｏ算式, usize)> {
-    let (原子式, mut 游標) = self.剖析原子式(游標)?;
-
-    // TODO: 將算子棧算元棧包裝到一個 struct 裡
-    let mut 算元棧 = VecDeque::<Ｏ算式>::new();
-    算元棧.push_back(原子式);
 
-    let mut 算子棧 = VecDeque::<Ｏ運算子>::new();
-
-    while let Some((新算子, 新游標)) = self.消耗運算子(游標) {
-        let (新算元, 新游標) = self.剖析原子式(新游標)?;
+struct 調車場 {
+    算元棧: VecDeque<Ｏ算式>,
+    算子棧: VecDeque<Ｏ運算子>,
+}
 
+impl 調車場 {
+    fn new(首個算元: Ｏ算式) -> Self {
+        Self {
+            算元棧: vec![首個算元].into(),
+            算子棧: vec![].into(),
+        }
+    }
+    fn 結合棧中算子(&mut self) {
+        let 右算元 = self.算元棧.pop_back().unwrap();
+        let 左算元 = self.算元棧.pop_back().unwrap();
+        let 運算子 = self.算子棧.pop_back().unwrap();
+        self.算元棧.push_back(Ｏ算式::二元運算(Ｏ二元運算 {
+            運算子,
+            左: Box::new(左算元),
+            右: Box::new(右算元),
+        }));
+    }
+    fn 讀取(&mut self, 新算子: Ｏ運算子, 新算元: Ｏ算式) {
         // 讀取到新算子，進行棧操作
-        while !算子棧.is_empty() && 優先級(算子棧.back().unwrap()) >= 優先級(&新算子)
+        while !self.算子棧.is_empty() && 優先級(self.算子棧.back().unwrap()) >= 優先級(&新算子)
         {
             // 新算子優先級較低，代表棧中的算子算元可以先結合了。
-            let 右算元 = 算元棧.pop_back().unwrap();
-            let 左算元 = 算元棧.pop_back().unwrap();
-            let 運算子 = 算子棧.pop_back().unwrap();
-            算元棧.push_back(Ｏ算式::二元運算(Ｏ二元運算 {
-                運算子,
-                左: Box::new(左算元),
-                右: Box::new(右算元),
-            }));
+            self.結合棧中算子();
         }
+        // 棧中能結合的算子跟算元都結合了，推入新算子跟算元
+        self.算子棧.push_back(新算子);
+        self.算元棧.push_back(新算元);
+    }
 
-        // 原式中能決定結合的算子跟算元都決定了，推入新算子跟算元
-        算子棧.push_back(新算子);
-        算元棧.push_back(新算元);
+    fn 結束(&mut self) -> Ｏ算式 {
+        while !self.算子棧.is_empty() {
+            self.結合棧中算子();
+        }
+        assert_eq!(self.算子棧.len(), 0);
+        assert_eq!(self.算元棧.len(), 1);
 
-        游標 = 新游標
+        self.算元棧.pop_back().unwrap()
     }
+}
 
-    while !算子棧.is_empty() {
-        // 無新算子，棧中的算子算元最右向左依次結合
-        // TODO: 封裝此二相同 while 內容
-        let 右算元 = 算元棧.pop_back().unwrap();
-        let 左算元 = 算元棧.pop_back().unwrap();
-        let 運算子 = 算子棧.pop_back().unwrap();
-        算元棧.push_back(Ｏ算式::二元運算(Ｏ二元運算 {
-            運算子,
-            左: Box::new(左算元),
-            右: Box::new(右算元),
-        }));
-    }
+```
+
+#### 遞迴實作：優先級爬升算法
+TODO:
 
-    assert_eq!(算元棧.len(), 1);
 
-    Some((算元棧.pop_back().unwrap(), 游標))
+### 混用回溯剖析與優先級決定算法
+
+那吾人不妨在剖析器中將算子、算元與括號順序保留，再由此優先級爬升算法來處理優先級。
+
+```語法
+算式      = 原子式・(算子・原子式)*
+
+原子式    = 數字
+         | 變數
+         | "（"・算式・"）"
+```
+
+由於括號已經由原子式處理，在剖析算式中不需要處理括號，應用前述的調車場算法即可。
+
+```rust
+fn 剖析算式(&self, 游標: usize) -> Option<(Ｏ算式, usize)> {
+    let (原子式, mut 游標) = self.剖析原子式(游標)?;
+
+    let mut 調車場 = 調車場::new(原子式);
+
+    while let Some((新算子, 新游標)) = self.消耗運算子(游標) {
+        let (新算元, 新游標) = self.剖析原子式(新游標)?;
+
+        調車場.讀取(新算子, 新算元);
+
+        游標 = 新游標
+    }
+
+    Some((調車場.結束(), 游標))
 }
 ```