Sync zh and zh-hant versions.

zh-hant/codes/rust/chapter_array_and_linkedlist/my_list.rs

@@ -90,7 +90,7 @@ impl MyList {
             panic!("索引越界")
         };
         let num = self.arr[index];
-        // 將將索引 index 之後的元素都向前移動一位
+        // 將索引 index 之後的元素都向前移動一位
         for j in index..self.size - 1 {
             self.arr[j] = self.arr[j + 1];
         }

zh-hant/codes/rust/chapter_heap/heap.rs

@@ -13,22 +13,12 @@ fn test_push_max(heap: &mut BinaryHeap<i32>, val: i32) {
     println!("\n元素 {} 入堆積後", val);
     print_util::print_heap(heap.iter().map(|&val| val).collect());
 }
-fn test_push_min(heap: &mut BinaryHeap<Reverse<i32>>, val: i32) {
-    heap.push(Reverse(val)); // 元素入堆積
-    println!("\n元素 {} 入堆積後", val);
-    print_util::print_heap(heap.iter().map(|&val| val.0).collect());
-}
 
 fn test_pop_max(heap: &mut BinaryHeap<i32>) {
     let val = heap.pop().unwrap();
     println!("\n堆積頂元素 {} 出堆積後", val);
     print_util::print_heap(heap.iter().map(|&val| val).collect());
 }
-fn test_pop_min(heap: &mut BinaryHeap<Reverse<i32>>) {
-    let val = heap.pop().unwrap().0;
-    println!("\n堆積頂元素 {} 出堆積後", val);
-    print_util::print_heap(heap.iter().map(|&val| val.0).collect());
-}
 
 /* Driver Code */
 fn main() {

zh-hant/codes/rust/chapter_stack_and_queue/array_deque.rs

@@ -5,17 +5,17 @@
  */
 use hello_algo_rust::include::print_util;
 /* 基於環形陣列實現的雙向佇列 */
-struct ArrayDeque {
-    nums: Vec<i32>,  // 用於儲存雙向佇列元素的陣列
+struct ArrayDeque<T> {
+    nums: Vec<T>,    // 用於儲存雙向佇列元素的陣列
     front: usize,    // 佇列首指標，指向佇列首元素
     que_size: usize, // 雙向佇列長度
 }
 
-impl ArrayDeque {
+impl<T: Copy + Default> ArrayDeque<T> {
     /* 建構子 */
     pub fn new(capacity: usize) -> Self {
         Self {
-            nums: vec![0; capacity],
+            nums: vec![T::default(); capacity],
             front: 0,
             que_size: 0,
         }
@@ -41,11 +41,11 @@ impl ArrayDeque {
         // 透過取餘操作實現陣列首尾相連
         // 當 i 越過陣列尾部後，回到頭部
         // 當 i 越過陣列頭部後，回到尾部
-        return ((i + self.capacity() as i32) % self.capacity() as i32) as usize;
+        ((i + self.capacity() as i32) % self.capacity() as i32) as usize
     }
 
     /* 佇列首入列 */
-    pub fn push_first(&mut self, num: i32) {
+    pub fn push_first(&mut self, num: T) {
         if self.que_size == self.capacity() {
             println!("雙向佇列已滿");
             return;
@@ -59,7 +59,7 @@ impl ArrayDeque {
     }
 
     /* 佇列尾入列 */
-    pub fn push_last(&mut self, num: i32) {
+    pub fn push_last(&mut self, num: T) {
         if self.que_size == self.capacity() {
             println!("雙向佇列已滿");
             return;
@@ -72,7 +72,7 @@ impl ArrayDeque {
     }
 
     /* 佇列首出列 */
-    fn pop_first(&mut self) -> i32 {
+    fn pop_first(&mut self) -> T {
         let num = self.peek_first();
         // 佇列首指標向後移動一位
         self.front = self.index(self.front as i32 + 1);
@@ -81,14 +81,14 @@ impl ArrayDeque {
     }
 
     /* 佇列尾出列 */
-    fn pop_last(&mut self) -> i32 {
+    fn pop_last(&mut self) -> T {
         let num = self.peek_last();
         self.que_size -= 1;
         num
     }
 
     /* 訪問佇列首元素 */
-    fn peek_first(&self) -> i32 {
+    fn peek_first(&self) -> T {
         if self.is_empty() {
             panic!("雙向佇列為空")
         };
@@ -96,7 +96,7 @@ impl ArrayDeque {
     }
 
     /* 訪問佇列尾元素 */
-    fn peek_last(&self) -> i32 {
+    fn peek_last(&self) -> T {
         if self.is_empty() {
             panic!("雙向佇列為空")
         };
@@ -106,9 +106,9 @@ impl ArrayDeque {
     }
 
     /* 返回陣列用於列印 */
-    fn to_array(&self) -> Vec<i32> {
+    fn to_array(&self) -> Vec<T> {
         // 僅轉換有效長度範圍內的串列元素
-        let mut res = vec![0; self.que_size];
+        let mut res = vec![T::default(); self.que_size];
         let mut j = self.front;
         for i in 0..self.que_size {
             res[i] = self.nums[self.index(j as i32)];

zh-hant/codes/rust/chapter_stack_and_queue/array_queue.rs

@@ -5,18 +5,18 @@
  */
 
 /* 基於環形陣列實現的佇列 */
-struct ArrayQueue {
-    nums: Vec<i32>,    // 用於儲存佇列元素的陣列
+struct ArrayQueue<T> {
+    nums: Vec<T>,      // 用於儲存佇列元素的陣列
     front: i32,        // 佇列首指標，指向佇列首元素
     que_size: i32,     // 佇列長度
     que_capacity: i32, // 佇列容量
 }
 
-impl ArrayQueue {
+impl<T: Copy + Default> ArrayQueue<T> {
     /* 建構子 */
-    fn new(capacity: i32) -> ArrayQueue {
+    fn new(capacity: i32) -> ArrayQueue<T> {
         ArrayQueue {
-            nums: vec![0; capacity as usize],
+            nums: vec![T::default(); capacity as usize],
             front: 0,
             que_size: 0,
             que_capacity: capacity,
@@ -39,7 +39,7 @@ impl ArrayQueue {
     }
 
     /* 入列 */
-    fn push(&mut self, num: i32) {
+    fn push(&mut self, num: T) {
         if self.que_size == self.capacity() {
             println!("佇列已滿");
             return;
@@ -53,7 +53,7 @@ impl ArrayQueue {
     }
 
     /* 出列 */
-    fn pop(&mut self) -> i32 {
+    fn pop(&mut self) -> T {
         let num = self.peek();
         // 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部
         self.front = (self.front + 1) % self.que_capacity;
@@ -62,7 +62,7 @@ impl ArrayQueue {
     }
 
     /* 訪問佇列首元素 */
-    fn peek(&self) -> i32 {
+    fn peek(&self) -> T {
         if self.is_empty() {
             panic!("index out of bounds");
         }
@@ -70,10 +70,10 @@ impl ArrayQueue {
     }
 
     /* 返回陣列 */
-    fn to_vector(&self) -> Vec<i32> {
+    fn to_vector(&self) -> Vec<T> {
         let cap = self.que_capacity;
         let mut j = self.front;
-        let mut arr = vec![0; self.que_size as usize];
+        let mut arr = vec![T::default(); cap as usize];
         for i in 0..self.que_size {
             arr[i as usize] = self.nums[(j % cap) as usize];
             j += 1;

zh-hant/codes/rust/chapter_stack_and_queue/linkedlist_deque.rs

@@ -50,11 +50,11 @@ impl<T: Copy> LinkedListDeque<T> {
 
     /* 判斷雙向佇列是否為空 */
     pub fn is_empty(&self) -> bool {
-        return self.size() == 0;
+        return self.que_size == 0;
     }
 
     /* 入列操作 */
-    pub fn push(&mut self, num: T, is_front: bool) {
+    fn push(&mut self, num: T, is_front: bool) {
         let node = ListNode::new(num);
         // 佇列首入列操作
         if is_front {
@@ -102,7 +102,7 @@ impl<T: Copy> LinkedListDeque<T> {
     }
 
     /* 出列操作 */
-    pub fn pop(&mut self, is_front: bool) -> Option<T> {
+    fn pop(&mut self, is_front: bool) -> Option<T> {
         // 若佇列為空，直接返回 None
         if self.is_empty() {
             return None;

zh-hant/codes/rust/chapter_stack_and_queue/linkedlist_queue.rs

@@ -33,7 +33,7 @@ impl<T: Copy> LinkedListQueue<T> {
 
     /* 判斷佇列是否為空 */
     pub fn is_empty(&self) -> bool {
-        return self.size() == 0;
+        return self.que_size == 0;
     }
 
     /* 入列 */

zh-hant/codes/rust/chapter_stack_and_queue/linkedlist_stack.rs

@@ -58,14 +58,18 @@ impl<T: Copy> LinkedListStack<T> {
     }
 
     /* 將 List 轉化為 Array 並返回 */
-    pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {
+    pub fn to_array(&self) -> Vec<T> {
+        fn _to_array<T: Sized + Copy>(head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {
             if let Some(node) = head {
-            let mut nums = self.to_array(node.borrow().next.as_ref());
+                let mut nums = _to_array(node.borrow().next.as_ref());
                 nums.push(node.borrow().val);
                 return nums;
             }
             return Vec::new();
         }
+
+        _to_array(self.peek())
+    }
 }
 
 /* Driver Code */
@@ -80,7 +84,7 @@ fn main() {
     stack.push(5);
     stack.push(4);
     print!("堆疊 stack = ");
-    print_util::print_array(&stack.to_array(stack.peek()));
+    print_util::print_array(&stack.to_array());
 
     /* 訪問堆疊頂元素 */
     let peek = stack.peek().unwrap().borrow().val;
@@ -89,7 +93,7 @@ fn main() {
     /* 元素出堆疊 */
     let pop = stack.pop().unwrap();
     print!("\n出堆疊元素 pop = {}，出堆疊後 stack = ", pop);
-    print_util::print_array(&stack.to_array(stack.peek()));
+    print_util::print_array(&stack.to_array());
 
     /* 獲取堆疊的長度 */
     let size = stack.size();

zh-hant/codes/rust/src/include/tree_node.rs

@@ -34,7 +34,7 @@ impl TreeNode {
 macro_rules! op_vec {
     ( $( $x:expr ),* ) => {
         vec![
-            $( Option::from($x).map(|x| x) ),*
+            $(Option::from($x)),*
         ]
     };
 }

zh-hant/docs/chapter_computational_complexity/time_complexity.md

@@ -751,7 +751,7 @@ $T(n)$ 是一次函式，說明其執行時間的增長趨勢是線性的，因
 
     若存在正實數 $c$ 和實數 $n_0$ ，使得對於所有的 $n > n_0$ ，均有 $T(n) \leq c \cdot f(n)$ ，則可認為 $f(n)$ 給出了 $T(n)$ 的一個漸近上界，記為 $T(n) = O(f(n))$ 。
 
-如下圖所示，計算漸近上界就是尋找一個函式 $f(n)$ ，使得當 $n$ 趨向於無窮大時，$T(n)$ 和 $f(n)$ 處於相同的增長級別，僅相差一個常數項 $c$ 的倍數。
+如下圖所示，計算漸近上界就是尋找一個函式 $f(n)$ ，使得當 $n$ 趨向於無窮大時，$T(n)$ 和 $f(n)$ 處於相同的增長級別，僅相差一個常數係數 $c$。
 
 ![函式的漸近上界](time_complexity.assets/asymptotic_upper_bound.png)
 
@@ -763,9 +763,9 @@ $T(n)$ 是一次函式，說明其執行時間的增長趨勢是線性的，因
 
 ### 第一步：統計操作數量
 
-針對程式碼，逐行從上到下計算即可。然而，由於上述 $c \cdot f(n)$ 中的常數項 $c$ 可以取任意大小，**因此操作數量 $T(n)$ 中的各種係數、常數項都可以忽略**。根據此原則，可以總結出以下計數簡化技巧。
+針對程式碼，逐行從上到下計算即可。然而，由於上述 $c \cdot f(n)$ 中的常數係數 $c$ 可以取任意大小，**因此操作數量 $T(n)$ 中的各種係數、常數項都可以忽略**。根據此原則，可以總結出以下計數簡化技巧。
 
-1. **忽略 $T(n)$ 中的常數項**。因為它們都與 $n$ 無關，所以對時間複雜度不產生影響。
+1. **忽略 $T(n)$ 中的常數**。因為它們都與 $n$ 無關，所以對時間複雜度不產生影響。
 2. **省略所有係數**。例如，迴圈 $2n$ 次、$5n + 1$ 次等，都可以簡化記為 $n$ 次，因為 $n$ 前面的係數對時間複雜度沒有影響。
 3. **迴圈巢狀時使用乘法**。總操作數量等於外層迴圈和內層迴圈操作數量之積，每一層迴圈依然可以分別套用第 `1.` 點和第 `2.` 點的技巧。