Polish the chapter

introduction, computational complexity.

codes/rust/chapter_computational_complexity/time_complexity.rs

@@ -139,32 +139,32 @@ fn main() {
     println!("输入数据大小 n = {}", n);
 
     let mut count = constant(n);
-    println!("常数阶的计算操作数量 = {}", count);
+    println!("常数阶的操作数量 = {}", count);
 
     count = linear(n);
-    println!("线性阶的计算操作数量 = {}", count);
+    println!("线性阶的操作数量 = {}", count);
     count = array_traversal(&vec![0; n as usize]);
-    println!("线性阶（遍历数组）的计算操作数量 = {}", count);
+    println!("线性阶（遍历数组）的操作数量 = {}", count);
 
     count = quadratic(n);
-    println!("平方阶的计算操作数量 = {}", count);
+    println!("平方阶的操作数量 = {}", count);
     let mut nums = (1..=n).rev().collect::<Vec<_>>(); // [n,n-1,...,2,1]
     count = bubble_sort(&mut nums);
-    println!("平方阶（冒泡排序）的计算操作数量 = {}", count);
+    println!("平方阶（冒泡排序）的操作数量 = {}", count);
 
     count = exponential(n);
-    println!("指数阶（循环实现）的计算操作数量 = {}", count);
+    println!("指数阶（循环实现）的操作数量 = {}", count);
     count = exp_recur(n);
-    println!("指数阶（递归实现）的计算操作数量 = {}", count);
+    println!("指数阶（递归实现）的操作数量 = {}", count);
 
     count = logarithmic(n as f32);
-    println!("对数阶（循环实现）的计算操作数量 = {}", count);
+    println!("对数阶（循环实现）的操作数量 = {}", count);
     count = log_recur(n as f32);
-    println!("对数阶（递归实现）的计算操作数量 = {}", count);
+    println!("对数阶（递归实现）的操作数量 = {}", count);
 
     count = linear_log_recur(n as f32);
-    println!("线性对数阶（递归实现）的计算操作数量 = {}", count);
+    println!("线性对数阶（递归实现）的操作数量 = {}", count);
 
     count = factorial_recur(n);
-    println!("阶乘阶（递归实现）的计算操作数量 = {}", count);
+    println!("阶乘阶（递归实现）的操作数量 = {}", count);
 }

codes/rust/chapter_heap/my_heap.rs

@@ -8,7 +8,7 @@ include!("../include/include.rs");
 
 /* 大顶堆 */
 struct MaxHeap {
-    // 使用 vector 而非数组，这样无需考虑扩容问题
+    // 使用 vector 而非数组，这样无须考虑扩容问题
     max_heap: Vec<i32>,
 }
 
@@ -76,7 +76,7 @@ impl MaxHeap {
             }
             // 获取节点 i 的父节点
             let p = Self::parent(i);
-            // 当“节点无需修复”时，结束堆化
+            // 当“节点无须修复”时，结束堆化
             if self.max_heap[i] <= self.max_heap[p] {
                 break;
             }
@@ -114,7 +114,7 @@ impl MaxHeap {
             if r < self.size() && self.max_heap[r] > self.max_heap[ma] {
                 ma = r;
             }
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if ma == i {
                 break;
             }

codes/rust/chapter_sorting/heap_sort.rs

@@ -19,7 +19,7 @@ fn sift_down(nums: &mut [i32], n: usize, mut i: usize) {
         if r < n && nums[r] > nums[ma] {
             ma = r;
         }
-        // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
         if ma == i {
             break;
         }

codes/rust/chapter_tree/avl_tree.rs

@@ -123,7 +123,7 @@ impl AVLTree {
                 Self::left_rotate(Some(node))
             }
         } else {
-            // 平衡树，无需旋转，直接返回
+            // 平衡树，无须旋转，直接返回
             node
         }
     }