build

docs/chapter_array_and_linkedlist/array.md

@@ -924,7 +924,8 @@ comments: true
             _count += nums[i];
         }
         // 直接遍历数组元素
-        for num in nums {
+        _count = 0;
+        for &num in nums {
             _count += num;
         }
     }
@@ -1359,9 +1360,8 @@ comments: true
         // 初始化一个扩展长度后的数组
         let mut res: Vec<i32> = vec![0; nums.len() + enlarge];
         // 将原数组中的所有元素复制到新
-        for i in 0..nums.len() {
-            res[i] = nums[i];
-        }
+        res[0..nums.len()].copy_from_slice(nums);
+
         // 返回扩展后的新数组
         res
     }

docs/chapter_array_and_linkedlist/linked_list.md

@@ -777,9 +777,6 @@ comments: true
     /* 删除链表的节点 n0 之后的首个节点 */
     #[allow(non_snake_case)]
     pub fn remove<T>(n0: &Rc<RefCell<ListNode<T>>>) {
-        if n0.borrow().next.is_none() {
-            return;
-        };
         // n0 -> P -> n1
         let P = n0.borrow_mut().next.take();
         if let Some(node) = P {
@@ -988,15 +985,23 @@ comments: true
 
     ```rust title="linked_list.rs"
     /* 访问链表中索引为 index 的节点 */
-    pub fn access<T>(head: Rc<RefCell<ListNode<T>>>, index: i32) -> Rc<RefCell<ListNode<T>>> {
-        if index <= 0 {
-            return head;
-        };
-        if let Some(node) = &head.borrow().next {
-            return access(node.clone(), index - 1);
+    pub fn access<T>(head: Rc<RefCell<ListNode<T>>>, index: i32) -> Option<Rc<RefCell<ListNode<T>>>> {
+        fn dfs<T>(
+            head: Option<&Rc<RefCell<ListNode<T>>>>,
+            index: i32,
+        ) -> Option<Rc<RefCell<ListNode<T>>>> {
+            if index <= 0 {
+                return head.cloned();
+            }
+
+            if let Some(node) = head {
+                dfs(node.borrow().next.as_ref(), index - 1)
+            } else {
+                None
+            }
         }
 
-        return head;
+        dfs(Some(head).as_ref(), index)
     }
     ```
 
@@ -1219,14 +1224,19 @@ comments: true
 
     ```rust title="linked_list.rs"
     /* 在链表中查找值为 target 的首个节点 */
-    pub fn find<T: PartialEq>(head: Rc<RefCell<ListNode<T>>>, target: T, index: i32) -> i32 {
-        if head.borrow().val == target {
-            return index;
-        };
-        if let Some(node) = &head.borrow_mut().next {
-            return find(node.clone(), target, index + 1);
+    pub fn find<T: PartialEq>(head: Rc<RefCell<ListNode<T>>>, target: T) -> i32 {
+        fn find<T: PartialEq>(head: Option<&Rc<RefCell<ListNode<T>>>>, target: T, idx: i32) -> i32 {
+            if let Some(node) = head {
+                if node.borrow().val == target {
+                    return idx;
+                }
+                return find(node.borrow().next.as_ref(), target, idx + 1);
+            } else {
+                -1
+            }
         }
-        return -1;
+
+        find(Some(head).as_ref(), target, 0)
     }
     ```
 

docs/chapter_computational_complexity/performance_evaluation.md

@@ -28,7 +28,7 @@ comments: true
 
 ## 2.1.2   理论估算
 
-由于实际测试具有较大的局限性，因此我们可以考虑仅通过一些计算来评估算法的效率。这种估算方法被称为<u>渐近复杂度分析（asymptotic complexity analysis）</u>，简称<u>复杂度分析</u>。
+由于实际测试具有较大的局限性，我们可以考虑仅通过一些计算来评估算法的效率。这种估算方法被称为<u>渐近复杂度分析（asymptotic complexity analysis）</u>，简称<u>复杂度分析</u>。
 
 复杂度分析能够体现算法运行所需的时间和空间资源与输入数据大小之间的关系。**它描述了随着输入数据大小的增加，算法执行所需时间和空间的增长趋势**。这个定义有些拗口，我们可以将其分为三个重点来理解。
 

docs/chapter_hashing/hash_algorithm.md

@@ -661,7 +661,7 @@ index = hash(key) % capacity
 
 观察发现，每种哈希算法的最后一步都是对大质数 $1000000007$ 取模，以确保哈希值在合适的范围内。值得思考的是，为什么要强调对质数取模，或者说对合数取模的弊端是什么？这是一个有趣的问题。
 
-先抛出结论：**使用大质数作为模数，可以最大化地保证哈希值的均匀分布**。因为质数不与其他数字存在公约数，可以减少因取模操作而产生的周期性模式，从而避免哈希冲突。
+先给出结论：**使用大质数作为模数，可以最大化地保证哈希值的均匀分布**。因为质数不与其他数字存在公约数，可以减少因取模操作而产生的周期性模式，从而避免哈希冲突。
 
 举个例子，假设我们选择合数 $9$ 作为模数，它可以被 $3$ 整除，那么所有可以被 $3$ 整除的 `key` 都会被映射到 $0$、$3$、$6$ 这三个哈希值。