codes/csharp/chapter_dynamic_programming/min_path_sum.cs

@@ -105,7 +105,7 @@ public class min_path_sum {
 
         // 暴力搜索
         int res = MinPathSumDFS(grid, n - 1, m - 1);
-        Console.WriteLine("从左上角到右下角的最小路径和为 " + res);
+        Console.WriteLine("从左上角到右下角的做小路径和为 " + res);
 
         // 记忆化搜索
         int[][] mem = new int[n][];
@@ -114,14 +114,14 @@ public class min_path_sum {
             Array.Fill(mem[i], -1);
         }
         res = MinPathSumDFSMem(grid, mem, n - 1, m - 1);
-        Console.WriteLine("从左上角到右下角的最小路径和为 " + res);
+        Console.WriteLine("从左上角到右下角的做小路径和为 " + res);
 
         // 动态规划
         res = MinPathSumDP(grid);
-        Console.WriteLine("从左上角到右下角的最小路径和为 " + res);
+        Console.WriteLine("从左上角到右下角的做小路径和为 " + res);
 
         // 空间优化后的动态规划
         res = MinPathSumDPComp(grid);
-        Console.WriteLine("从左上角到右下角的最小路径和为 " + res);
+        Console.WriteLine("从左上角到右下角的做小路径和为 " + res);
     }
 }

codes/csharp/chapter_heap/heap.cs

@@ -24,8 +24,8 @@ public class heap {
         /* 初始化堆 */
         // 初始化小顶堆
         PriorityQueue<int, int> minHeap = new();
-        // 初始化大顶堆（使用 lambda 表达式修改 Comparer 即可）
+        // 初始化大顶堆（使用 lambda 表达式修改 Comparator 即可）
-        PriorityQueue<int, int> maxHeap = new(Comparer<int>.Create((x, y) => y.CompareTo(x)));
+        PriorityQueue<int, int> maxHeap = new(Comparer<int>.Create((x, y) => y - x));
         Console.WriteLine("以下测试样例为大顶堆");
 
         /* 元素入堆 */

codes/dart/chapter_dynamic_programming/min_path_sum.dart

@@ -103,18 +103,18 @@ void main() {
 
 // 暴力搜索
   int res = minPathSumDFS(grid, n - 1, m - 1);
-  print("从左上角到右下角的最小路径和为 $res");
+  print("从左上角到右下角的做小路径和为 $res");
 
 // 记忆化搜索
   List<List<int>> mem = List.generate(n, (i) => List.filled(m, -1));
   res = minPathSumDFSMem(grid, mem, n - 1, m - 1);
-  print("从左上角到右下角的最小路径和为 $res");
+  print("从左上角到右下角的做小路径和为 $res");
 
 // 动态规划
   res = minPathSumDP(grid);
-  print("从左上角到右下角的最小路径和为 $res");
+  print("从左上角到右下角的做小路径和为 $res");
 
 // 空间优化后的动态规划
   res = minPathSumDPComp(grid);
-  print("从左上角到右下角的最小路径和为 $res");
+  print("从左上角到右下角的做小路径和为 $res");
 }

codes/go/chapter_dynamic_programming/min_path_sum_test.go

@@ -20,7 +20,7 @@ func TestMinPathSum(t *testing.T) {
 
 	// 暴力搜索
 	res := minPathSumDFS(grid, n-1, m-1)
-	fmt.Printf("从左上角到右下角的最小路径和为  %d\n", res)
+	fmt.Printf("从左上角到右下角的做小路径和为  %d\n", res)
 
 	// 记忆化搜索
 	mem := make([][]int, n)
@@ -31,13 +31,13 @@ func TestMinPathSum(t *testing.T) {
 		}
 	}
 	res = minPathSumDFSMem(grid, mem, n-1, m-1)
-	fmt.Printf("从左上角到右下角的最小路径和为  %d\n", res)
+	fmt.Printf("从左上角到右下角的做小路径和为  %d\n", res)
 
 	// 动态规划
 	res = minPathSumDP(grid)
-	fmt.Printf("从左上角到右下角的最小路径和为  %d\n", res)
+	fmt.Printf("从左上角到右下角的做小路径和为  %d\n", res)
 
 	// 空间优化后的动态规划
 	res = minPathSumDPComp(grid)
-	fmt.Printf("从左上角到右下角的最小路径和为  %d\n", res)
+	fmt.Printf("从左上角到右下角的做小路径和为  %d\n", res)
 }

codes/python/chapter_dynamic_programming/min_path_sum.py

@@ -88,17 +88,17 @@ if __name__ == "__main__":
 
     # 暴力搜索
     res = min_path_sum_dfs(grid, n - 1, m - 1)
-    print(f"从左上角到右下角的最小路径和为 {res}")
+    print(f"从左上角到右下角的做小路径和为 {res}")
 
     # 记忆化搜索
     mem = [[-1] * m for _ in range(n)]
     res = min_path_sum_dfs_mem(grid, mem, n - 1, m - 1)
-    print(f"从左上角到右下角的最小路径和为 {res}")
+    print(f"从左上角到右下角的做小路径和为 {res}")
 
     # 动态规划
     res = min_path_sum_dp(grid)
-    print(f"从左上角到右下角的最小路径和为 {res}")
+    print(f"从左上角到右下角的做小路径和为 {res}")
 
     # 空间优化后的动态规划
     res = min_path_sum_dp_comp(grid)
-    print(f"从左上角到右下角的最小路径和为 {res}")
+    print(f"从左上角到右下角的做小路径和为 {res}")

codes/ruby/chapter_dynamic_programming/min_path_sum.rb

@@ -76,18 +76,18 @@ if __FILE__ == $0
 
   # 暴力搜索
   res = min_path_sum_dfs(grid, n - 1, m - 1)
-  puts "从左上角到右下角的最小路径和为 #{res}"
+  puts "从左上角到右下角的做小路径和为 #{res}"
 
   # 记忆化搜索
   mem = Array.new(n) { Array.new(m, - 1) }
   res = min_path_sum_dfs_mem(grid, mem, n - 1, m -1)
-  puts "从左上角到右下角的最小路径和为 #{res}"
+  puts "从左上角到右下角的做小路径和为 #{res}"
 
   # 动态规划
   res = min_path_sum_dp(grid)
-  puts "从左上角到右下角的最小路径和为 #{res}"
+  puts "从左上角到右下角的做小路径和为 #{res}"
 
   # 空间优化后的动态规划
   res = min_path_sum_dp_comp(grid)
-  puts "从左上角到右下角的最小路径和为 #{res}"
+  puts "从左上角到右下角的做小路径和为 #{res}"
 end

codes/rust/chapter_tree/array_binary_tree.rs

@@ -49,11 +49,18 @@ impl ArrayBinaryTree {
 
     /* 层序遍历 */
     fn level_order(&self) -> Vec<i32> {
-        self.tree.iter().filter_map(|&x| x).collect()
+        let mut res = vec![];
+        // 直接遍历数组
+        for i in 0..self.size() {
+            if let Some(val) = self.val(i) {
+                res.push(val)
+            }
+        }
+        res
     }
 
     /* 深度优先遍历 */
-    fn dfs(&self, i: i32, order: &'static str, res: &mut Vec<i32>) {
+    fn dfs(&self, i: i32, order: &str, res: &mut Vec<i32>) {
         if self.val(i).is_none() {
             return;
         }

codes/rust/chapter_tree/binary_search_tree.rs

@@ -126,7 +126,7 @@ impl BinarySearchTree {
                 // 删除节点 cur
                 if !Rc::ptr_eq(&cur, self.root.as_ref().unwrap()) {
                     let left = pre.borrow().left.clone();
-                    if left.is_some() && Rc::ptr_eq(left.as_ref().unwrap(), &cur) {
+                    if left.is_some() && Rc::ptr_eq(&left.as_ref().unwrap(), &cur) {
                         pre.borrow_mut().left = child;
                     } else {
                         pre.borrow_mut().right = child;
@@ -147,11 +147,11 @@ impl BinarySearchTree {
                         break;
                     }
                 }
-                let tmp_val = tmp.unwrap().borrow().val;
+                let tmpval = tmp.unwrap().borrow().val;
                 // 递归删除节点 tmp
-                self.remove(tmp_val);
+                self.remove(tmpval);
                 // 用 tmp 覆盖 cur
-                cur.borrow_mut().val = tmp_val;
+                cur.borrow_mut().val = tmpval;
             }
         }
     }

codes/rust/chapter_tree/binary_tree_dfs.rs

@@ -4,7 +4,7 @@
  * Author: xBLACKICEx (xBLACKICE@outlook.com)
  */
 
-use hello_algo_rust::include::{print_util, vec_to_tree, TreeNode};
+use hello_algo_rust::include::{vec_to_tree, TreeNode, print_util};
 use hello_algo_rust::op_vec;
 
 use std::cell::RefCell;
@@ -14,17 +14,12 @@ use std::rc::Rc;
 fn pre_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
     let mut result = vec![];
 
-    fn dfs(root: Option<&Rc<RefCell<TreeNode>>>, res: &mut Vec<i32>) {
+    if let Some(node) = root {
-        if let Some(node) = root {
+        // 访问优先级：根节点 -> 左子树 -> 右子树
-            // 访问优先级：根节点 -> 左子树 -> 右子树
+        result.push(node.borrow().val);
-            let node = node.borrow();
+        result.extend(pre_order(node.borrow().left.as_ref()));
-            res.push(node.val);
+        result.extend(pre_order(node.borrow().right.as_ref()));
-            dfs(node.left.as_ref(), res);
-            dfs(node.right.as_ref(), res);
-        }
     }
-    dfs(root, &mut result);
-
     result
 }
 
@@ -32,17 +27,12 @@ fn pre_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
 fn in_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
     let mut result = vec![];
 
-    fn dfs(root: Option<&Rc<RefCell<TreeNode>>>, res: &mut Vec<i32>) {
+    if let Some(node) = root {
-        if let Some(node) = root {
+        // 访问优先级：左子树 -> 根节点 -> 右子树
-            // 访问优先级：左子树 -> 根节点 -> 右子树
+        result.extend(in_order(node.borrow().left.as_ref()));
-            let node = node.borrow();
+        result.push(node.borrow().val);
-            dfs(node.left.as_ref(), res);
+        result.extend(in_order(node.borrow().right.as_ref()));
-            res.push(node.val);
-            dfs(node.right.as_ref(), res);
-        }
     }
-    dfs(root, &mut result);
-
     result
 }
 
@@ -50,18 +40,12 @@ fn in_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
 fn post_order(root: Option<&Rc<RefCell<TreeNode>>>) -> Vec<i32> {
     let mut result = vec![];
 
-    fn dfs(root: Option<&Rc<RefCell<TreeNode>>>, res: &mut Vec<i32>) {
+    if let Some(node) = root {
-        if let Some(node) = root {
+        // 访问优先级：左子树 -> 右子树 -> 根节点
-            // 访问优先级：左子树 -> 右子树 -> 根节点
+        result.extend(post_order(node.borrow().left.as_ref()));
-            let node = node.borrow();
+        result.extend(post_order(node.borrow().right.as_ref()));
-            dfs(node.left.as_ref(), res);
+        result.push(node.borrow().val);
-            dfs(node.right.as_ref(), res);
-            res.push(node.val);
-        }
     }
-
-    dfs(root, &mut result);
-
     result
 }
 

codes/swift/chapter_dynamic_programming/min_path_sum.swift

@@ -105,19 +105,19 @@ enum MinPathSum {
 
         // 暴力搜索
         var res = minPathSumDFS(grid: grid, i: n - 1, j: m - 1)
-        print("从左上角到右下角的最小路径和为 \(res)")
+        print("从左上角到右下角的做小路径和为 \(res)")
 
         // 记忆化搜索
         var mem = Array(repeating: Array(repeating: -1, count: m), count: n)
         res = minPathSumDFSMem(grid: grid, mem: &mem, i: n - 1, j: m - 1)
-        print("从左上角到右下角的最小路径和为 \(res)")
+        print("从左上角到右下角的做小路径和为 \(res)")
 
         // 动态规划
         res = minPathSumDP(grid: grid)
-        print("从左上角到右下角的最小路径和为 \(res)")
+        print("从左上角到右下角的做小路径和为 \(res)")
 
         // 空间优化后的动态规划
         res = minPathSumDPComp(grid: grid)
-        print("从左上角到右下角的最小路径和为 \(res)")
+        print("从左上角到右下角的做小路径和为 \(res)")
     }
 }

docs/chapter_heap/heap.md

@@ -157,8 +157,8 @@
     /* 初始化堆 */
     // 初始化小顶堆
     PriorityQueue<int, int> minHeap = new();
-    // 初始化大顶堆（使用 lambda 表达式修改 Comparer 即可）
+    // 初始化大顶堆（使用 lambda 表达式修改 Comparator 即可）
-    PriorityQueue<int, int> maxHeap = new(Comparer<int>.Create((x, y) => y.CompareTo(x)));
+    PriorityQueue<int, int> maxHeap = new(Comparer<int>.Create((x, y) => y - x));
 
     /* 元素入堆 */
     maxHeap.Enqueue(1, 1);