diff --git a/codes/c/chapter_computational_complexity/time_complexity.c b/codes/c/chapter_computational_complexity/time_complexity.c
index 1b70b0df..39e7942f 100644
--- a/codes/c/chapter_computational_complexity/time_complexity.c
+++ b/codes/c/chapter_computational_complexity/time_complexity.c
@@ -135,38 +135,38 @@ int main(int argc, char *argv[]) {
     printf("输入数据大小 n = %d\n", n);
 
     int count = constant(n);
-    printf("常数阶的计算操作数量 = %d\n", count);
+    printf("常数阶的操作数量 = %d\n", count);
 
     count = linear(n);
-    printf("线性阶的计算操作数量 = %d\n", count);
+    printf("线性阶的操作数量 = %d\n", count);
     // 分配堆区内存（创建一维可变长数组：数组中元素数量为n，元素类型为int）
     int *nums = (int *)malloc(n * sizeof(int));
     count = arrayTraversal(nums, n);
-    printf("线性阶（遍历数组）的计算操作数量 = %d\n", count);
+    printf("线性阶（遍历数组）的操作数量 = %d\n", count);
 
     count = quadratic(n);
-    printf("平方阶的计算操作数量 = %d\n", count);
+    printf("平方阶的操作数量 = %d\n", count);
     for (int i = 0; i < n; i++) {
         nums[i] = n - i; // [n,n-1,...,2,1]
     }
     count = bubbleSort(nums, n);
-    printf("平方阶（冒泡排序）的计算操作数量 = %d\n", count);
+    printf("平方阶（冒泡排序）的操作数量 = %d\n", count);
 
     count = exponential(n);
-    printf("指数阶（循环实现）的计算操作数量 = %d\n", count);
+    printf("指数阶（循环实现）的操作数量 = %d\n", count);
     count = expRecur(n);
-    printf("指数阶（递归实现）的计算操作数量 = %d\n", count);
+    printf("指数阶（递归实现）的操作数量 = %d\n", count);
 
     count = logarithmic(n);
-    printf("对数阶（循环实现）的计算操作数量 = %d\n", count);
+    printf("对数阶（循环实现）的操作数量 = %d\n", count);
     count = logRecur(n);
-    printf("对数阶（递归实现）的计算操作数量 = %d\n", count);
+    printf("对数阶（递归实现）的操作数量 = %d\n", count);
 
     count = linearLogRecur(n);
-    printf("线性对数阶（递归实现）的计算操作数量 = %d\n", count);
+    printf("线性对数阶（递归实现）的操作数量 = %d\n", count);
 
     count = factorialRecur(n);
-    printf("阶乘阶（递归实现）的计算操作数量 = %d\n", count);
+    printf("阶乘阶（递归实现）的操作数量 = %d\n", count);
 
     // 释放堆区内存
     if (nums != NULL) {
diff --git a/codes/c/chapter_heap/my_heap.c b/codes/c/chapter_heap/my_heap.c
index d9f7729f..04a421a6 100644
--- a/codes/c/chapter_heap/my_heap.c
+++ b/codes/c/chapter_heap/my_heap.c
@@ -119,7 +119,7 @@ void siftDown(maxHeap *h, int i) {
         if (r < size(h) && h->data[r] > h->data[max]) {
             max = r;
         }
-        // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
         if (max == i) {
             break;
         }
@@ -135,7 +135,7 @@ void siftUp(maxHeap *h, int i) {
     while (true) {
         // 获取节点 i 的父节点
         int p = parent(h, i);
-        // 当“越过根节点”或“节点无需修复”时，结束堆化
+        // 当“越过根节点”或“节点无须修复”时，结束堆化
         if (p < 0 || h->data[i] <= h->data[p]) {
             break;
         }
diff --git a/codes/c/chapter_sorting/heap_sort.c b/codes/c/chapter_sorting/heap_sort.c
index 084aa0a5..6af0a63f 100644
--- a/codes/c/chapter_sorting/heap_sort.c
+++ b/codes/c/chapter_sorting/heap_sort.c
@@ -17,7 +17,7 @@ void siftDown(int nums[], int n, int i) {
             ma = l;
         if (r < n && nums[r] > nums[ma])
             ma = r;
-        // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
         if (ma == i) {
             break;
         }
diff --git a/codes/c/chapter_tree/avl_tree.c b/codes/c/chapter_tree/avl_tree.c
index 309bd85d..23f79986 100644
--- a/codes/c/chapter_tree/avl_tree.c
+++ b/codes/c/chapter_tree/avl_tree.c
@@ -107,7 +107,7 @@ TreeNode *rotate(TreeNode *node) {
             return leftRotate(node);
         }
     }
-    // 平衡树，无需旋转，直接返回
+    // 平衡树，无须旋转，直接返回
     return node;
 }
 
diff --git a/codes/cpp/chapter_computational_complexity/time_complexity.cpp b/codes/cpp/chapter_computational_complexity/time_complexity.cpp
index 90b9a0ae..c4fb1fd2 100644
--- a/codes/cpp/chapter_computational_complexity/time_complexity.cpp
+++ b/codes/cpp/chapter_computational_complexity/time_complexity.cpp
@@ -132,37 +132,37 @@ int main() {
     cout << "输入数据大小 n = " << n << endl;
 
     int count = constant(n);
-    cout << "常数阶的计算操作数量 = " << count << endl;
+    cout << "常数阶的操作数量 = " << count << endl;
 
     count = linear(n);
-    cout << "线性阶的计算操作数量 = " << count << endl;
+    cout << "线性阶的操作数量 = " << count << endl;
     vector<int> arr(n);
     count = arrayTraversal(arr);
-    cout << "线性阶（遍历数组）的计算操作数量 = " << count << endl;
+    cout << "线性阶（遍历数组）的操作数量 = " << count << endl;
 
     count = quadratic(n);
-    cout << "平方阶的计算操作数量 = " << count << endl;
+    cout << "平方阶的操作数量 = " << count << endl;
     vector<int> nums(n);
     for (int i = 0; i < n; i++)
         nums[i] = n - i; // [n,n-1,...,2,1]
     count = bubbleSort(nums);
-    cout << "平方阶（冒泡排序）的计算操作数量 = " << count << endl;
+    cout << "平方阶（冒泡排序）的操作数量 = " << count << endl;
 
     count = exponential(n);
-    cout << "指数阶（循环实现）的计算操作数量 = " << count << endl;
+    cout << "指数阶（循环实现）的操作数量 = " << count << endl;
     count = expRecur(n);
-    cout << "指数阶（递归实现）的计算操作数量 = " << count << endl;
+    cout << "指数阶（递归实现）的操作数量 = " << count << endl;
 
     count = logarithmic((float)n);
-    cout << "对数阶（循环实现）的计算操作数量 = " << count << endl;
+    cout << "对数阶（循环实现）的操作数量 = " << count << endl;
     count = logRecur((float)n);
-    cout << "对数阶（递归实现）的计算操作数量 = " << count << endl;
+    cout << "对数阶（递归实现）的操作数量 = " << count << endl;
 
     count = linearLogRecur((float)n);
-    cout << "线性对数阶（递归实现）的计算操作数量 = " << count << endl;
+    cout << "线性对数阶（递归实现）的操作数量 = " << count << endl;
 
     count = factorialRecur(n);
-    cout << "阶乘阶（递归实现）的计算操作数量 = " << count << endl;
+    cout << "阶乘阶（递归实现）的操作数量 = " << count << endl;
 
     return 0;
 }
diff --git a/codes/cpp/chapter_heap/my_heap.cpp b/codes/cpp/chapter_heap/my_heap.cpp
index 8854bfee..4cc11d43 100644
--- a/codes/cpp/chapter_heap/my_heap.cpp
+++ b/codes/cpp/chapter_heap/my_heap.cpp
@@ -9,7 +9,7 @@
 /* 大顶堆 */
 class MaxHeap {
   private:
-    // 使用动态数组，这样无需考虑扩容问题
+    // 使用动态数组，这样无须考虑扩容问题
     vector<int> maxHeap;
 
     /* 获取左子节点索引 */
@@ -32,7 +32,7 @@ class MaxHeap {
         while (true) {
             // 获取节点 i 的父节点
             int p = parent(i);
-            // 当“越过根节点”或“节点无需修复”时，结束堆化
+            // 当“越过根节点”或“节点无须修复”时，结束堆化
             if (p < 0 || maxHeap[i] <= maxHeap[p])
                 break;
             // 交换两节点
@@ -47,12 +47,12 @@ class MaxHeap {
         while (true) {
             // 判断节点 i, l, r 中值最大的节点，记为 ma
             int l = left(i), r = right(i), ma = i;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (l < size() && maxHeap[l] > maxHeap[ma])
                 ma = l;
             if (r < size() && maxHeap[r] > maxHeap[ma])
                 ma = r;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma == i)
                 break;
             swap(maxHeap[i], maxHeap[ma]);
diff --git a/codes/cpp/chapter_sorting/heap_sort.cpp b/codes/cpp/chapter_sorting/heap_sort.cpp
index 57af471c..8df0dbc2 100644
--- a/codes/cpp/chapter_sorting/heap_sort.cpp
+++ b/codes/cpp/chapter_sorting/heap_sort.cpp
@@ -17,7 +17,7 @@ void siftDown(vector<int> &nums, int n, int i) {
             ma = l;
         if (r < n && nums[r] > nums[ma])
             ma = r;
-        // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
         if (ma == i) {
             break;
         }
diff --git a/codes/cpp/chapter_tree/avl_tree.cpp b/codes/cpp/chapter_tree/avl_tree.cpp
index 5aaca253..04c08b66 100644
--- a/codes/cpp/chapter_tree/avl_tree.cpp
+++ b/codes/cpp/chapter_tree/avl_tree.cpp
@@ -71,7 +71,7 @@ class AVLTree {
                 return leftRotate(node);
             }
         }
-        // 平衡树，无需旋转，直接返回
+        // 平衡树，无须旋转，直接返回
         return node;
     }
 
diff --git a/codes/csharp/chapter_computational_complexity/time_complexity.cs b/codes/csharp/chapter_computational_complexity/time_complexity.cs
index 34719ffb..e9d6f946 100644
--- a/codes/csharp/chapter_computational_complexity/time_complexity.cs
+++ b/codes/csharp/chapter_computational_complexity/time_complexity.cs
@@ -160,35 +160,35 @@ public class time_complexity {
         Console.WriteLine("输入数据大小 n = " + n);
 
         int count = constant(n);
-        Console.WriteLine("常数阶的计算操作数量 = " + count);
+        Console.WriteLine("常数阶的操作数量 = " + count);
 
         count = linear(n);
-        Console.WriteLine("线性阶的计算操作数量 = " + count);
+        Console.WriteLine("线性阶的操作数量 = " + count);
         count = arrayTraversal(new int[n]);
-        Console.WriteLine("线性阶（遍历数组）的计算操作数量 = " + count);
+        Console.WriteLine("线性阶（遍历数组）的操作数量 = " + count);
 
         count = quadratic(n);
-        Console.WriteLine("平方阶的计算操作数量 = " + count);
+        Console.WriteLine("平方阶的操作数量 = " + count);
         int[] nums = new int[n];
         for (int i = 0; i < n; i++)
             nums[i] = n - i;  // [n,n-1,...,2,1]
         count = bubbleSort(nums);
-        Console.WriteLine("平方阶（冒泡排序）的计算操作数量 = " + count);
+        Console.WriteLine("平方阶（冒泡排序）的操作数量 = " + count);
 
         count = exponential(n);
-        Console.WriteLine("指数阶（循环实现）的计算操作数量 = " + count);
+        Console.WriteLine("指数阶（循环实现）的操作数量 = " + count);
         count = expRecur(n);
-        Console.WriteLine("指数阶（递归实现）的计算操作数量 = " + count);
+        Console.WriteLine("指数阶（递归实现）的操作数量 = " + count);
 
         count = logarithmic((float)n);
-        Console.WriteLine("对数阶（循环实现）的计算操作数量 = " + count);
+        Console.WriteLine("对数阶（循环实现）的操作数量 = " + count);
         count = logRecur((float)n);
-        Console.WriteLine("对数阶（递归实现）的计算操作数量 = " + count);
+        Console.WriteLine("对数阶（递归实现）的操作数量 = " + count);
 
         count = linearLogRecur((float)n);
-        Console.WriteLine("线性对数阶（递归实现）的计算操作数量 = " + count);
+        Console.WriteLine("线性对数阶（递归实现）的操作数量 = " + count);
 
         count = factorialRecur(n);
-        Console.WriteLine("阶乘阶（递归实现）的计算操作数量 = " + count);
+        Console.WriteLine("阶乘阶（递归实现）的操作数量 = " + count);
     }
 }
diff --git a/codes/csharp/chapter_heap/my_heap.cs b/codes/csharp/chapter_heap/my_heap.cs
index 5918787c..0f039388 100644
--- a/codes/csharp/chapter_heap/my_heap.cs
+++ b/codes/csharp/chapter_heap/my_heap.cs
@@ -8,7 +8,7 @@ namespace hello_algo.chapter_heap;
 
 /* 大顶堆 */
 class MaxHeap {
-    // 使用列表而非数组，这样无需考虑扩容问题
+    // 使用列表而非数组，这样无须考虑扩容问题
     private readonly List<int> maxHeap;
 
     /* 构造函数，建立空堆 */
@@ -70,7 +70,7 @@ class MaxHeap {
         while (true) {
             // 获取节点 i 的父节点
             int p = parent(i);
-            // 若“越过根节点”或“节点无需修复”，则结束堆化
+            // 若“越过根节点”或“节点无须修复”，则结束堆化
             if (p < 0 || maxHeap[i] <= maxHeap[p])
                 break;
             // 交换两节点
diff --git a/codes/csharp/chapter_sorting/heap_sort.cs b/codes/csharp/chapter_sorting/heap_sort.cs
index d6074fae..47a87241 100644
--- a/codes/csharp/chapter_sorting/heap_sort.cs
+++ b/codes/csharp/chapter_sorting/heap_sort.cs
@@ -18,7 +18,7 @@ public class heap_sort {
                 ma = l;
             if (r < n && nums[r] > nums[ma])
                 ma = r;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma == i)
                 break;
             // 交换两节点
diff --git a/codes/csharp/chapter_tree/avl_tree.cs b/codes/csharp/chapter_tree/avl_tree.cs
index 9c13a91d..5e0d6f0f 100644
--- a/codes/csharp/chapter_tree/avl_tree.cs
+++ b/codes/csharp/chapter_tree/avl_tree.cs
@@ -84,7 +84,7 @@ class AVLTree {
                 return leftRotate(node);
             }
         }
-        // 平衡树，无需旋转，直接返回
+        // 平衡树，无须旋转，直接返回
         return node;
     }
 
diff --git a/codes/dart/chapter_computational_complexity/time_complexity.dart b/codes/dart/chapter_computational_complexity/time_complexity.dart
index 32cd7e2a..fc9f64ee 100644
--- a/codes/dart/chapter_computational_complexity/time_complexity.dart
+++ b/codes/dart/chapter_computational_complexity/time_complexity.dart
@@ -128,36 +128,36 @@ void main() {
   print('输入数据大小 n = $n');
 
   int count = constant(n);
-  print('常数阶的计算操作数量 = $count');
+  print('常数阶的操作数量 = $count');
 
   count = linear(n);
-  print('线性阶的计算操作数量 = $count');
+  print('线性阶的操作数量 = $count');
 
   count = arrayTraversal(List.filled(n, 0));
-  print('线性阶（遍历数组）的计算操作数量 = $count');
+  print('线性阶（遍历数组）的操作数量 = $count');
 
   count = quadratic(n);
-  print('平方阶的计算操作数量 = $count');
+  print('平方阶的操作数量 = $count');
   final nums = List.filled(n, 0);
   for (int i = 0; i < n; i++) {
     nums[i] = n - i; // [n,n-1,...,2,1]
   }
   count = bubbleSort(nums);
-  print('平方阶（冒泡排序）的计算操作数量 = $count');
+  print('平方阶（冒泡排序）的操作数量 = $count');
 
   count = exponential(n);
-  print('指数阶（循环实现）的计算操作数量 = $count');
+  print('指数阶（循环实现）的操作数量 = $count');
   count = expRecur(n);
-  print('指数阶（递归实现）的计算操作数量 = $count');
+  print('指数阶（递归实现）的操作数量 = $count');
 
   count = logarithmic(n);
-  print('对数阶（循环实现）的计算操作数量 = $count');
+  print('对数阶（循环实现）的操作数量 = $count');
   count = logRecur(n);
-  print('对数阶（递归实现）的计算操作数量 = $count');
+  print('对数阶（递归实现）的操作数量 = $count');
 
   count = linearLogRecur(n);
-  print('线性对数阶（递归实现）的计算操作数量 = $count');
+  print('线性对数阶（递归实现）的操作数量 = $count');
 
   count = factorialRecur(n);
-  print('阶乘阶（递归实现）的计算操作数量 = $count');
+  print('阶乘阶（递归实现）的操作数量 = $count');
 }
diff --git a/codes/dart/chapter_heap/my_heap.dart b/codes/dart/chapter_heap/my_heap.dart
index 23659b4b..b7b95e4b 100644
--- a/codes/dart/chapter_heap/my_heap.dart
+++ b/codes/dart/chapter_heap/my_heap.dart
@@ -70,7 +70,7 @@ class MaxHeap {
     while (true) {
       // 获取节点 i 的父节点
       int p = _parent(i);
-      // 当“越过根节点”或“节点无需修复”时，结束堆化
+      // 当“越过根节点”或“节点无须修复”时，结束堆化
       if (p < 0 || _maxHeap[i] <= _maxHeap[p]) {
         break;
       }
@@ -104,7 +104,7 @@ class MaxHeap {
       int ma = i;
       if (l < size() && _maxHeap[l] > _maxHeap[ma]) ma = l;
       if (r < size() && _maxHeap[r] > _maxHeap[ma]) ma = r;
-      // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+      // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
       if (ma == i) break;
       // 交换两节点
       _swap(i, ma);
diff --git a/codes/dart/chapter_heap/top_k.dart b/codes/dart/chapter_heap/top_k.dart
index 9101eb9f..72cb8166 100644
--- a/codes/dart/chapter_heap/top_k.dart
+++ b/codes/dart/chapter_heap/top_k.dart
@@ -100,7 +100,7 @@ class MinHeap {
     while (true) {
       // 获取节点 i 的父节点
       int p = _parent(i);
-      // 当“越过根节点”或“节点无需修复”时，结束堆化
+      // 当“越过根节点”或“节点无须修复”时，结束堆化
       if (p < 0 || _minHeap[i] >= _minHeap[p]) {
         break;
       }
@@ -134,7 +134,7 @@ class MinHeap {
       int mi = i;
       if (l < size() && _minHeap[l] < _minHeap[mi]) mi = l;
       if (r < size() && _minHeap[r] < _minHeap[mi]) mi = r;
-      // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+      // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
       if (mi == i) break;
       // 交换两节点
       _swap(i, mi);
diff --git a/codes/dart/chapter_sorting/heap_sort.dart b/codes/dart/chapter_sorting/heap_sort.dart
index 0eef5d08..ef8222ad 100644
--- a/codes/dart/chapter_sorting/heap_sort.dart
+++ b/codes/dart/chapter_sorting/heap_sort.dart
@@ -13,7 +13,7 @@ void siftDown(List<int> nums, int n, int i) {
     int ma = i;
     if (l < n && nums[l] > nums[ma]) ma = l;
     if (r < n && nums[r] > nums[ma]) ma = r;
-    // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+    // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
     if (ma == i) break;
     // 交换两节点
     int temp = nums[i];
diff --git a/codes/dart/chapter_tree/avl_tree.dart b/codes/dart/chapter_tree/avl_tree.dart
index b68096e6..710d1c15 100644
--- a/codes/dart/chapter_tree/avl_tree.dart
+++ b/codes/dart/chapter_tree/avl_tree.dart
@@ -90,7 +90,7 @@ class AVLTree {
         return leftRotate(node);
       }
     }
-    // 平衡树，无需旋转，直接返回
+    // 平衡树，无须旋转，直接返回
     return node;
   }
 
diff --git a/codes/go/chapter_computational_complexity/time_complexity_test.go b/codes/go/chapter_computational_complexity/time_complexity_test.go
index 6486a59f..adfbdd8d 100644
--- a/codes/go/chapter_computational_complexity/time_complexity_test.go
+++ b/codes/go/chapter_computational_complexity/time_complexity_test.go
@@ -14,35 +14,35 @@ func TestTimeComplexity(t *testing.T) {
 	fmt.Println("输入数据大小 n =", n)
 
 	count := constant(n)
-	fmt.Println("常数阶的计算操作数量 =", count)
+	fmt.Println("常数阶的操作数量 =", count)
 
 	count = linear(n)
-	fmt.Println("线性阶的计算操作数量 =", count)
+	fmt.Println("线性阶的操作数量 =", count)
 	count = arrayTraversal(make([]int, n))
-	fmt.Println("线性阶（遍历数组）的计算操作数量 =", count)
+	fmt.Println("线性阶（遍历数组）的操作数量 =", count)
 
 	count = quadratic(n)
-	fmt.Println("平方阶的计算操作数量 =", count)
+	fmt.Println("平方阶的操作数量 =", count)
 	nums := make([]int, n)
 	for i := 0; i < n; i++ {
 		nums[i] = n - i
 	}
 	count = bubbleSort(nums)
-	fmt.Println("平方阶（冒泡排序）的计算操作数量 =", count)
+	fmt.Println("平方阶（冒泡排序）的操作数量 =", count)
 
 	count = exponential(n)
-	fmt.Println("指数阶（循环实现）的计算操作数量 =", count)
+	fmt.Println("指数阶（循环实现）的操作数量 =", count)
 	count = expRecur(n)
-	fmt.Println("指数阶（递归实现）的计算操作数量 =", count)
+	fmt.Println("指数阶（递归实现）的操作数量 =", count)
 
 	count = logarithmic(float64(n))
-	fmt.Println("对数阶（循环实现）的计算操作数量 =", count)
+	fmt.Println("对数阶（循环实现）的操作数量 =", count)
 	count = logRecur(float64(n))
-	fmt.Println("对数阶（递归实现）的计算操作数量 =", count)
+	fmt.Println("对数阶（递归实现）的操作数量 =", count)
 
 	count = linearLogRecur(float64(n))
-	fmt.Println("线性对数阶（递归实现）的计算操作数量 =", count)
+	fmt.Println("线性对数阶（递归实现）的操作数量 =", count)
 
 	count = factorialRecur(n)
-	fmt.Println("阶乘阶（递归实现）的计算操作数量 =", count)
+	fmt.Println("阶乘阶（递归实现）的操作数量 =", count)
 }
diff --git a/codes/go/chapter_heap/my_heap.go b/codes/go/chapter_heap/my_heap.go
index adedd1f6..841ef0e1 100644
--- a/codes/go/chapter_heap/my_heap.go
+++ b/codes/go/chapter_heap/my_heap.go
@@ -11,7 +11,7 @@ import (
 )
 
 type maxHeap struct {
-	// 使用切片而非数组，这样无需考虑扩容问题
+	// 使用切片而非数组，这样无须考虑扩容问题
 	data []any
 }
 
@@ -82,7 +82,7 @@ func (h *maxHeap) siftUp(i int) {
 	for true {
 		// 获取节点 i 的父节点
 		p := h.parent(i)
-		// 当“越过根节点”或“节点无需修复”时，结束堆化
+		// 当“越过根节点”或“节点无须修复”时，结束堆化
 		if p < 0 || h.data[i].(int) <= h.data[p].(int) {
 			break
 		}
@@ -123,7 +123,7 @@ func (h *maxHeap) siftDown(i int) {
 		if r < h.size() && h.data[r].(int) > h.data[max].(int) {
 			max = r
 		}
-		// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+		// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
 		if max == i {
 			break
 		}
diff --git a/codes/go/chapter_sorting/heap_sort.go b/codes/go/chapter_sorting/heap_sort.go
index 7f610dfd..1cac8a68 100644
--- a/codes/go/chapter_sorting/heap_sort.go
+++ b/codes/go/chapter_sorting/heap_sort.go
@@ -17,7 +17,7 @@ func siftDown(nums *[]int, n, i int) {
 		if r < n && (*nums)[r] > (*nums)[ma] {
 			ma = r
 		}
-		// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+		// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
 		if ma == i {
 			break
 		}
diff --git a/codes/go/chapter_tree/avl_tree.go b/codes/go/chapter_tree/avl_tree.go
index 244813fe..9f2cd980 100644
--- a/codes/go/chapter_tree/avl_tree.go
+++ b/codes/go/chapter_tree/avl_tree.go
@@ -102,7 +102,7 @@ func (t *aVLTree) rotate(node *TreeNode) *TreeNode {
 			return t.leftRotate(node)
 		}
 	}
-	// 平衡树，无需旋转，直接返回
+	// 平衡树，无须旋转，直接返回
 	return node
 }
 
diff --git a/codes/java/chapter_computational_complexity/time_complexity.java b/codes/java/chapter_computational_complexity/time_complexity.java
index f7061b5d..121ae968 100644
--- a/codes/java/chapter_computational_complexity/time_complexity.java
+++ b/codes/java/chapter_computational_complexity/time_complexity.java
@@ -134,35 +134,35 @@ public class time_complexity {
         System.out.println("输入数据大小 n = " + n);
 
         int count = constant(n);
-        System.out.println("常数阶的计算操作数量 = " + count);
+        System.out.println("常数阶的操作数量 = " + count);
 
         count = linear(n);
-        System.out.println("线性阶的计算操作数量 = " + count);
+        System.out.println("线性阶的操作数量 = " + count);
         count = arrayTraversal(new int[n]);
-        System.out.println("线性阶（遍历数组）的计算操作数量 = " + count);
+        System.out.println("线性阶（遍历数组）的操作数量 = " + count);
 
         count = quadratic(n);
-        System.out.println("平方阶的计算操作数量 = " + count);
+        System.out.println("平方阶的操作数量 = " + count);
         int[] nums = new int[n];
         for (int i = 0; i < n; i++)
             nums[i] = n - i; // [n,n-1,...,2,1]
         count = bubbleSort(nums);
-        System.out.println("平方阶（冒泡排序）的计算操作数量 = " + count);
+        System.out.println("平方阶（冒泡排序）的操作数量 = " + count);
 
         count = exponential(n);
-        System.out.println("指数阶（循环实现）的计算操作数量 = " + count);
+        System.out.println("指数阶（循环实现）的操作数量 = " + count);
         count = expRecur(n);
-        System.out.println("指数阶（递归实现）的计算操作数量 = " + count);
+        System.out.println("指数阶（递归实现）的操作数量 = " + count);
 
         count = logarithmic((float) n);
-        System.out.println("对数阶（循环实现）的计算操作数量 = " + count);
+        System.out.println("对数阶（循环实现）的操作数量 = " + count);
         count = logRecur((float) n);
-        System.out.println("对数阶（递归实现）的计算操作数量 = " + count);
+        System.out.println("对数阶（递归实现）的操作数量 = " + count);
 
         count = linearLogRecur((float) n);
-        System.out.println("线性对数阶（递归实现）的计算操作数量 = " + count);
+        System.out.println("线性对数阶（递归实现）的操作数量 = " + count);
 
         count = factorialRecur(n);
-        System.out.println("阶乘阶（递归实现）的计算操作数量 = " + count);
+        System.out.println("阶乘阶（递归实现）的操作数量 = " + count);
     }
 }
diff --git a/codes/java/chapter_heap/my_heap.java b/codes/java/chapter_heap/my_heap.java
index d9859bb5..2599abac 100644
--- a/codes/java/chapter_heap/my_heap.java
+++ b/codes/java/chapter_heap/my_heap.java
@@ -11,7 +11,7 @@ import java.util.*;
 
 /* 大顶堆 */
 class MaxHeap {
-    // 使用列表而非数组，这样无需考虑扩容问题
+    // 使用列表而非数组，这样无须考虑扩容问题
     private List<Integer> maxHeap;
 
     /* 构造方法，根据输入列表建堆 */
@@ -74,7 +74,7 @@ class MaxHeap {
         while (true) {
             // 获取节点 i 的父节点
             int p = parent(i);
-            // 当“越过根节点”或“节点无需修复”时，结束堆化
+            // 当“越过根节点”或“节点无须修复”时，结束堆化
             if (p < 0 || maxHeap.get(i) <= maxHeap.get(p))
                 break;
             // 交换两节点
@@ -108,7 +108,7 @@ class MaxHeap {
                 ma = l;
             if (r < size() && maxHeap.get(r) > maxHeap.get(ma))
                 ma = r;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma == i)
                 break;
             // 交换两节点
diff --git a/codes/java/chapter_sorting/heap_sort.java b/codes/java/chapter_sorting/heap_sort.java
index 514d8593..cb4ab50a 100644
--- a/codes/java/chapter_sorting/heap_sort.java
+++ b/codes/java/chapter_sorting/heap_sort.java
@@ -20,7 +20,7 @@ public class heap_sort {
                 ma = l;
             if (r < n && nums[r] > nums[ma])
                 ma = r;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma == i)
                 break;
             // 交换两节点
diff --git a/codes/java/chapter_tree/avl_tree.java b/codes/java/chapter_tree/avl_tree.java
index 967483fb..f8bbb424 100644
--- a/codes/java/chapter_tree/avl_tree.java
+++ b/codes/java/chapter_tree/avl_tree.java
@@ -87,7 +87,7 @@ class AVLTree {
                 return leftRotate(node);
             }
         }
-        // 平衡树，无需旋转，直接返回
+        // 平衡树，无须旋转，直接返回
         return node;
     }
 
diff --git a/codes/javascript/chapter_computational_complexity/time_complexity.js b/codes/javascript/chapter_computational_complexity/time_complexity.js
index 3e947813..bea5d2d0 100644
--- a/codes/javascript/chapter_computational_complexity/time_complexity.js
+++ b/codes/javascript/chapter_computational_complexity/time_complexity.js
@@ -124,32 +124,32 @@ const n = 8;
 console.log('输入数据大小 n = ' + n);
 
 let count = constant(n);
-console.log('常数阶的计算操作数量 = ' + count);
+console.log('常数阶的操作数量 = ' + count);
 
 count = linear(n);
-console.log('线性阶的计算操作数量 = ' + count);
+console.log('线性阶的操作数量 = ' + count);
 count = arrayTraversal(new Array(n));
-console.log('线性阶（遍历数组）的计算操作数量 = ' + count);
+console.log('线性阶（遍历数组）的操作数量 = ' + count);
 
 count = quadratic(n);
-console.log('平方阶的计算操作数量 = ' + count);
+console.log('平方阶的操作数量 = ' + count);
 let nums = new Array(n);
 for (let i = 0; i < n; i++) nums[i] = n - i; // [n,n-1,...,2,1]
 count = bubbleSort(nums);
-console.log('平方阶（冒泡排序）的计算操作数量 = ' + count);
+console.log('平方阶（冒泡排序）的操作数量 = ' + count);
 
 count = exponential(n);
-console.log('指数阶（循环实现）的计算操作数量 = ' + count);
+console.log('指数阶（循环实现）的操作数量 = ' + count);
 count = expRecur(n);
-console.log('指数阶（递归实现）的计算操作数量 = ' + count);
+console.log('指数阶（递归实现）的操作数量 = ' + count);
 
 count = logarithmic(n);
-console.log('对数阶（循环实现）的计算操作数量 = ' + count);
+console.log('对数阶（循环实现）的操作数量 = ' + count);
 count = logRecur(n);
-console.log('对数阶（递归实现）的计算操作数量 = ' + count);
+console.log('对数阶（递归实现）的操作数量 = ' + count);
 
 count = linearLogRecur(n);
-console.log('线性对数阶（递归实现）的计算操作数量 = ' + count);
+console.log('线性对数阶（递归实现）的操作数量 = ' + count);
 
 count = factorialRecur(n);
-console.log('阶乘阶（递归实现）的计算操作数量 = ' + count);
+console.log('阶乘阶（递归实现）的操作数量 = ' + count);
diff --git a/codes/javascript/chapter_heap/my_heap.js b/codes/javascript/chapter_heap/my_heap.js
index d37b64a1..6ef8c0dd 100644
--- a/codes/javascript/chapter_heap/my_heap.js
+++ b/codes/javascript/chapter_heap/my_heap.js
@@ -70,7 +70,7 @@ class MaxHeap {
         while (true) {
             // 获取节点 i 的父节点
             const p = this.#parent(i);
-            // 当“越过根节点”或“节点无需修复”时，结束堆化
+            // 当“越过根节点”或“节点无须修复”时，结束堆化
             if (p < 0 || this.#maxHeap[i] <= this.#maxHeap[p]) break;
             // 交换两节点
             this.#swap(i, p);
@@ -102,7 +102,7 @@ class MaxHeap {
             let ma = i;
             if (l < this.size() && this.#maxHeap[l] > this.#maxHeap[ma]) ma = l;
             if (r < this.size() && this.#maxHeap[r] > this.#maxHeap[ma]) ma = r;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma === i) break;
             // 交换两节点
             this.#swap(i, ma);
diff --git a/codes/javascript/chapter_sorting/heap_sort.js b/codes/javascript/chapter_sorting/heap_sort.js
index ce7ab482..0e8dcb86 100644
--- a/codes/javascript/chapter_sorting/heap_sort.js
+++ b/codes/javascript/chapter_sorting/heap_sort.js
@@ -17,7 +17,7 @@ function siftDown(nums, n, i) {
         if (r < n && nums[r] > nums[ma]) {
             ma = r;
         }
-        // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
         if (ma === i) {
             break;
         }
diff --git a/codes/javascript/chapter_tree/avl_tree.js b/codes/javascript/chapter_tree/avl_tree.js
index 0796cac1..6cb32b4e 100644
--- a/codes/javascript/chapter_tree/avl_tree.js
+++ b/codes/javascript/chapter_tree/avl_tree.js
@@ -89,7 +89,7 @@ class AVLTree {
                 return this.#leftRotate(node);
             }
         }
-        // 平衡树，无需旋转，直接返回
+        // 平衡树，无须旋转，直接返回
         return node;
     }
 
diff --git a/codes/python/chapter_computational_complexity/time_complexity.py b/codes/python/chapter_computational_complexity/time_complexity.py
index 3784de38..7ea3b483 100644
--- a/codes/python/chapter_computational_complexity/time_complexity.py
+++ b/codes/python/chapter_computational_complexity/time_complexity.py
@@ -121,31 +121,31 @@ if __name__ == "__main__":
     print("输入数据大小 n =", n)
 
     count: int = constant(n)
-    print("常数阶的计算操作数量 =", count)
+    print("常数阶的操作数量 =", count)
 
     count: int = linear(n)
-    print("线性阶的计算操作数量 =", count)
+    print("线性阶的操作数量 =", count)
     count: int = array_traversal([0] * n)
-    print("线性阶（遍历数组）的计算操作数量 =", count)
+    print("线性阶（遍历数组）的操作数量 =", count)
 
     count: int = quadratic(n)
-    print("平方阶的计算操作数量 =", count)
+    print("平方阶的操作数量 =", count)
     nums = [i for i in range(n, 0, -1)]  # [n, n-1, ..., 2, 1]
     count: int = bubble_sort(nums)
-    print("平方阶（冒泡排序）的计算操作数量 =", count)
+    print("平方阶（冒泡排序）的操作数量 =", count)
 
     count: int = exponential(n)
-    print("指数阶（循环实现）的计算操作数量 =", count)
+    print("指数阶（循环实现）的操作数量 =", count)
     count: int = exp_recur(n)
-    print("指数阶（递归实现）的计算操作数量 =", count)
+    print("指数阶（递归实现）的操作数量 =", count)
 
     count: int = logarithmic(n)
-    print("对数阶（循环实现）的计算操作数量 =", count)
+    print("对数阶（循环实现）的操作数量 =", count)
     count: int = log_recur(n)
-    print("对数阶（递归实现）的计算操作数量 =", count)
+    print("对数阶（递归实现）的操作数量 =", count)
 
     count: int = linear_log_recur(n)
-    print("线性对数阶（递归实现）的计算操作数量 =", count)
+    print("线性对数阶（递归实现）的操作数量 =", count)
 
     count: int = factorial_recur(n)
-    print("阶乘阶（递归实现）的计算操作数量 =", count)
+    print("阶乘阶（递归实现）的操作数量 =", count)
diff --git a/codes/python/chapter_heap/my_heap.py b/codes/python/chapter_heap/my_heap.py
index 435f3225..32f62b8d 100644
--- a/codes/python/chapter_heap/my_heap.py
+++ b/codes/python/chapter_heap/my_heap.py
@@ -61,7 +61,7 @@ class MaxHeap:
         while True:
             # 获取节点 i 的父节点
             p = self.parent(i)
-            # 当“越过根节点”或“节点无需修复”时，结束堆化
+            # 当“越过根节点”或“节点无须修复”时，结束堆化
             if p < 0 or self.max_heap[i] <= self.max_heap[p]:
                 break
             # 交换两节点
@@ -92,7 +92,7 @@ class MaxHeap:
                 ma = l
             if r < self.size() and self.max_heap[r] > self.max_heap[ma]:
                 ma = r
-            # 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            # 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if ma == i:
                 break
             # 交换两节点
diff --git a/codes/python/chapter_searching/binary_search.py b/codes/python/chapter_searching/binary_search.py
index 5f657e6e..26005ab2 100644
--- a/codes/python/chapter_searching/binary_search.py
+++ b/codes/python/chapter_searching/binary_search.py
@@ -11,7 +11,7 @@ def binary_search(nums: list[int], target: int) -> int:
     i, j = 0, len(nums) - 1
     # 循环，当搜索区间为空时跳出（当 i > j 时为空）
     while i <= j:
-        # 理论上 Python 的数字可以无限大（取决于内存大小），无需考虑大数越界问题
+        # 理论上 Python 的数字可以无限大（取决于内存大小），无须考虑大数越界问题
         m = (i + j) // 2  # 计算中点索引 m
         if nums[m] < target:
             i = m + 1  # 此情况说明 target 在区间 [m+1, j] 中
diff --git a/codes/python/chapter_sorting/heap_sort.py b/codes/python/chapter_sorting/heap_sort.py
index 6c75981a..7577d135 100644
--- a/codes/python/chapter_sorting/heap_sort.py
+++ b/codes/python/chapter_sorting/heap_sort.py
@@ -16,7 +16,7 @@ def sift_down(nums: list[int], n: int, i: int):
             ma = l
         if r < n and nums[r] > nums[ma]:
             ma = r
-        # 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+        # 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
         if ma == i:
             break
         # 交换两节点
diff --git a/codes/python/chapter_tree/avl_tree.py b/codes/python/chapter_tree/avl_tree.py
index cbbe14dd..4d255439 100644
--- a/codes/python/chapter_tree/avl_tree.py
+++ b/codes/python/chapter_tree/avl_tree.py
@@ -85,7 +85,7 @@ class AVLTree:
                 # 先右旋后左旋
                 node.right = self.__right_rotate(node.right)
                 return self.__left_rotate(node)
-        # 平衡树，无需旋转，直接返回
+        # 平衡树，无须旋转，直接返回
         return node
 
     def insert(self, val):
diff --git a/codes/rust/chapter_computational_complexity/time_complexity.rs b/codes/rust/chapter_computational_complexity/time_complexity.rs
index 615d18f6..66593152 100644
--- a/codes/rust/chapter_computational_complexity/time_complexity.rs
+++ b/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);
 }
diff --git a/codes/rust/chapter_heap/my_heap.rs b/codes/rust/chapter_heap/my_heap.rs
index 80f624b5..aeca99f1 100644
--- a/codes/rust/chapter_heap/my_heap.rs
+++ b/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;
             }
diff --git a/codes/rust/chapter_sorting/heap_sort.rs b/codes/rust/chapter_sorting/heap_sort.rs
index bc8ac16c..254d08df 100644
--- a/codes/rust/chapter_sorting/heap_sort.rs
+++ b/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;
         }
diff --git a/codes/rust/chapter_tree/avl_tree.rs b/codes/rust/chapter_tree/avl_tree.rs
index c8cf1e3e..3d62ae6b 100644
--- a/codes/rust/chapter_tree/avl_tree.rs
+++ b/codes/rust/chapter_tree/avl_tree.rs
@@ -123,7 +123,7 @@ impl AVLTree {
                 Self::left_rotate(Some(node))
             }
         } else {
-            // 平衡树，无需旋转，直接返回
+            // 平衡树，无须旋转，直接返回
             node
         }
     }
diff --git a/codes/swift/chapter_computational_complexity/time_complexity.swift b/codes/swift/chapter_computational_complexity/time_complexity.swift
index 1bf6c916..4b70c2e8 100644
--- a/codes/swift/chapter_computational_complexity/time_complexity.swift
+++ b/codes/swift/chapter_computational_complexity/time_complexity.swift
@@ -140,33 +140,33 @@ enum TimeComplexity {
         print("输入数据大小 n = \(n)")
 
         var count = constant(n: n)
-        print("常数阶的计算操作数量 = \(count)")
+        print("常数阶的操作数量 = \(count)")
 
         count = linear(n: n)
-        print("线性阶的计算操作数量 = \(count)")
+        print("线性阶的操作数量 = \(count)")
         count = arrayTraversal(nums: Array(repeating: 0, count: n))
-        print("线性阶（遍历数组）的计算操作数量 = \(count)")
+        print("线性阶（遍历数组）的操作数量 = \(count)")
 
         count = quadratic(n: n)
-        print("平方阶的计算操作数量 = \(count)")
+        print("平方阶的操作数量 = \(count)")
         var nums = Array(stride(from: n, to: 0, by: -1)) // [n,n-1,...,2,1]
         count = bubbleSort(nums: &nums)
-        print("平方阶（冒泡排序）的计算操作数量 = \(count)")
+        print("平方阶（冒泡排序）的操作数量 = \(count)")
 
         count = exponential(n: n)
-        print("指数阶（循环实现）的计算操作数量 = \(count)")
+        print("指数阶（循环实现）的操作数量 = \(count)")
         count = expRecur(n: n)
-        print("指数阶（递归实现）的计算操作数量 = \(count)")
+        print("指数阶（递归实现）的操作数量 = \(count)")
 
         count = logarithmic(n: Double(n))
-        print("对数阶（循环实现）的计算操作数量 = \(count)")
+        print("对数阶（循环实现）的操作数量 = \(count)")
         count = logRecur(n: Double(n))
-        print("对数阶（递归实现）的计算操作数量 = \(count)")
+        print("对数阶（递归实现）的操作数量 = \(count)")
 
         count = linearLogRecur(n: Double(n))
-        print("线性对数阶（递归实现）的计算操作数量 = \(count)")
+        print("线性对数阶（递归实现）的操作数量 = \(count)")
 
         count = factorialRecur(n: n)
-        print("阶乘阶（递归实现）的计算操作数量 = \(count)")
+        print("阶乘阶（递归实现）的操作数量 = \(count)")
     }
 }
diff --git a/codes/swift/chapter_heap/my_heap.swift b/codes/swift/chapter_heap/my_heap.swift
index 3588cae2..9bca6310 100644
--- a/codes/swift/chapter_heap/my_heap.swift
+++ b/codes/swift/chapter_heap/my_heap.swift
@@ -69,7 +69,7 @@ class MaxHeap {
         while true {
             // 获取节点 i 的父节点
             let p = parent(i: i)
-            // 当“越过根节点”或“节点无需修复”时，结束堆化
+            // 当“越过根节点”或“节点无须修复”时，结束堆化
             if p < 0 || maxHeap[i] <= maxHeap[p] {
                 break
             }
@@ -110,7 +110,7 @@ class MaxHeap {
             if r < size(), maxHeap[r] > maxHeap[ma] {
                 ma = r
             }
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if ma == i {
                 break
             }
diff --git a/codes/swift/chapter_sorting/heap_sort.swift b/codes/swift/chapter_sorting/heap_sort.swift
index c81f2d9d..cd84f76e 100644
--- a/codes/swift/chapter_sorting/heap_sort.swift
+++ b/codes/swift/chapter_sorting/heap_sort.swift
@@ -18,7 +18,7 @@ func siftDown(nums: inout [Int], n: Int, i: Int) {
         if r < n, nums[r] > nums[ma] {
             ma = r
         }
-        // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
         if ma == i {
             break
         }
diff --git a/codes/swift/chapter_tree/avl_tree.swift b/codes/swift/chapter_tree/avl_tree.swift
index 315d7f06..b8336796 100644
--- a/codes/swift/chapter_tree/avl_tree.swift
+++ b/codes/swift/chapter_tree/avl_tree.swift
@@ -84,7 +84,7 @@ class AVLTree {
                 return leftRotate(node: node)
             }
         }
-        // 平衡树，无需旋转，直接返回
+        // 平衡树，无须旋转，直接返回
         return node
     }
 
diff --git a/codes/typescript/chapter_computational_complexity/time_complexity.ts b/codes/typescript/chapter_computational_complexity/time_complexity.ts
index 25223058..9f4f4ed3 100644
--- a/codes/typescript/chapter_computational_complexity/time_complexity.ts
+++ b/codes/typescript/chapter_computational_complexity/time_complexity.ts
@@ -124,34 +124,34 @@ const n = 8;
 console.log('输入数据大小 n = ' + n);
 
 let count = constant(n);
-console.log('常数阶的计算操作数量 = ' + count);
+console.log('常数阶的操作数量 = ' + count);
 
 count = linear(n);
-console.log('线性阶的计算操作数量 = ' + count);
+console.log('线性阶的操作数量 = ' + count);
 count = arrayTraversal(new Array(n));
-console.log('线性阶（遍历数组）的计算操作数量 = ' + count);
+console.log('线性阶（遍历数组）的操作数量 = ' + count);
 
 count = quadratic(n);
-console.log('平方阶的计算操作数量 = ' + count);
+console.log('平方阶的操作数量 = ' + count);
 var nums = new Array(n);
 for (let i = 0; i < n; i++) nums[i] = n - i; // [n,n-1,...,2,1]
 count = bubbleSort(nums);
-console.log('平方阶（冒泡排序）的计算操作数量 = ' + count);
+console.log('平方阶（冒泡排序）的操作数量 = ' + count);
 
 count = exponential(n);
-console.log('指数阶（循环实现）的计算操作数量 = ' + count);
+console.log('指数阶（循环实现）的操作数量 = ' + count);
 count = expRecur(n);
-console.log('指数阶（递归实现）的计算操作数量 = ' + count);
+console.log('指数阶（递归实现）的操作数量 = ' + count);
 
 count = logarithmic(n);
-console.log('对数阶（循环实现）的计算操作数量 = ' + count);
+console.log('对数阶（循环实现）的操作数量 = ' + count);
 count = logRecur(n);
-console.log('对数阶（递归实现）的计算操作数量 = ' + count);
+console.log('对数阶（递归实现）的操作数量 = ' + count);
 
 count = linearLogRecur(n);
-console.log('线性对数阶（递归实现）的计算操作数量 = ' + count);
+console.log('线性对数阶（递归实现）的操作数量 = ' + count);
 
 count = factorialRecur(n);
-console.log('阶乘阶（递归实现）的计算操作数量 = ' + count);
+console.log('阶乘阶（递归实现）的操作数量 = ' + count);
 
 export {};
diff --git a/codes/typescript/chapter_heap/my_heap.ts b/codes/typescript/chapter_heap/my_heap.ts
index 298fe56c..0bf45d15 100644
--- a/codes/typescript/chapter_heap/my_heap.ts
+++ b/codes/typescript/chapter_heap/my_heap.ts
@@ -69,7 +69,7 @@ class MaxHeap {
         while (true) {
             // 获取节点 i 的父节点
             const p = this.parent(i);
-            // 当“越过根节点”或“节点无需修复”时，结束堆化
+            // 当“越过根节点”或“节点无须修复”时，结束堆化
             if (p < 0 || this.maxHeap[i] <= this.maxHeap[p]) break;
             // 交换两节点
             this.swap(i, p);
@@ -101,7 +101,7 @@ class MaxHeap {
             let ma = i;
             if (l < this.size() && this.maxHeap[l] > this.maxHeap[ma]) ma = l;
             if (r < this.size() && this.maxHeap[r] > this.maxHeap[ma]) ma = r;
-            // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+            // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
             if (ma === i) break;
             // 交换两节点
             this.swap(i, ma);
diff --git a/codes/typescript/chapter_sorting/heap_sort.ts b/codes/typescript/chapter_sorting/heap_sort.ts
index d9669f5d..daeb78a7 100644
--- a/codes/typescript/chapter_sorting/heap_sort.ts
+++ b/codes/typescript/chapter_sorting/heap_sort.ts
@@ -17,7 +17,7 @@ function siftDown(nums: number[], n: number, i: number): void {
         if (r < n && nums[r] > nums[ma]) {
             ma = r;
         }
-        // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+        // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
         if (ma === i) {
             break;
         }
diff --git a/codes/typescript/chapter_tree/avl_tree.ts b/codes/typescript/chapter_tree/avl_tree.ts
index 14ed33ed..3aea7d1e 100644
--- a/codes/typescript/chapter_tree/avl_tree.ts
+++ b/codes/typescript/chapter_tree/avl_tree.ts
@@ -90,7 +90,7 @@ class AVLTree {
                 return this.leftRotate(node);
             }
         }
-        // 平衡树，无需旋转，直接返回
+        // 平衡树，无须旋转，直接返回
         return node;
     }
 
diff --git a/codes/zig/chapter_computational_complexity/time_complexity.zig b/codes/zig/chapter_computational_complexity/time_complexity.zig
index 43270665..3327fb37 100644
--- a/codes/zig/chapter_computational_complexity/time_complexity.zig
+++ b/codes/zig/chapter_computational_complexity/time_complexity.zig
@@ -143,37 +143,37 @@ pub fn main() !void {
     std.debug.print("输入数据大小 n = {}\n", .{n});
 
     var count = constant(n);
-    std.debug.print("常数阶的计算操作数量 = {}\n", .{count});
+    std.debug.print("常数阶的操作数量 = {}\n", .{count});
 
     count = linear(n);
-    std.debug.print("线性阶的计算操作数量 = {}\n", .{count});
+    std.debug.print("线性阶的操作数量 = {}\n", .{count});
     var nums = [_]i32{0}**n;
     count = arrayTraversal(&nums);
-    std.debug.print("线性阶（遍历数组）的计算操作数量 = {}\n", .{count});
+    std.debug.print("线性阶（遍历数组）的操作数量 = {}\n", .{count});
 
     count = quadratic(n);
-    std.debug.print("平方阶的计算操作数量 = {}\n", .{count});
+    std.debug.print("平方阶的操作数量 = {}\n", .{count});
     for (&nums, 0..) |*num, i| {
         num.* = n - @as(i32, @intCast(i));  // [n,n-1,...,2,1]
     }
     count = bubbleSort(&nums);
-    std.debug.print("平方阶（冒泡排序）的计算操作数量 = {}\n", .{count});
+    std.debug.print("平方阶（冒泡排序）的操作数量 = {}\n", .{count});
 
     count = exponential(n);
-    std.debug.print("指数阶（循环实现）的计算操作数量 = {}\n", .{count});
+    std.debug.print("指数阶（循环实现）的操作数量 = {}\n", .{count});
     count = expRecur(n);
-    std.debug.print("指数阶（递归实现）的计算操作数量 = {}\n", .{count});
+    std.debug.print("指数阶（递归实现）的操作数量 = {}\n", .{count});
 
     count = logarithmic(@as(f32, n));
-    std.debug.print("对数阶（循环实现）的计算操作数量 = {}\n", .{count});
+    std.debug.print("对数阶（循环实现）的操作数量 = {}\n", .{count});
     count = logRecur(@as(f32, n));
-    std.debug.print("对数阶（递归实现）的计算操作数量 = {}\n", .{count});
+    std.debug.print("对数阶（递归实现）的操作数量 = {}\n", .{count});
 
     count = linearLogRecur(@as(f32, n));
-    std.debug.print("线性对数阶（递归实现）的计算操作数量 = {}\n", .{count});
+    std.debug.print("线性对数阶（递归实现）的操作数量 = {}\n", .{count});
 
     count = factorialRecur(n);
-    std.debug.print("阶乘阶（递归实现）的计算操作数量 = {}\n", .{count});
+    std.debug.print("阶乘阶（递归实现）的操作数量 = {}\n", .{count});
 
     _ = try std.io.getStdIn().reader().readByte();
 }
diff --git a/codes/zig/chapter_heap/my_heap.zig b/codes/zig/chapter_heap/my_heap.zig
index 8aa7d1cc..af3b9550 100644
--- a/codes/zig/chapter_heap/my_heap.zig
+++ b/codes/zig/chapter_heap/my_heap.zig
@@ -10,7 +10,7 @@ pub fn MaxHeap(comptime T: type) type {
     return struct {
         const Self = @This();
         
-        max_heap: ?std.ArrayList(T) = null,      // 使用列表而非数组，这样无需考虑扩容问题
+        max_heap: ?std.ArrayList(T) = null,      // 使用列表而非数组，这样无须考虑扩容问题
 
         // 构造方法，根据输入列表建堆
         pub fn init(self: *Self, allocator: std.mem.Allocator, nums: []const T) !void {
@@ -82,7 +82,7 @@ pub fn MaxHeap(comptime T: type) type {
             while (true) {
                 // 获取节点 i 的父节点
                 var p = parent(i);
-                // 当“越过根节点”或“节点无需修复”时，结束堆化
+                // 当“越过根节点”或“节点无须修复”时，结束堆化
                 if (p < 0 or self.max_heap.?.items[i] <= self.max_heap.?.items[p]) break;
                 // 交换两节点
                 try self.swap(i, p);
@@ -115,7 +115,7 @@ pub fn MaxHeap(comptime T: type) type {
                 var ma = i;
                 if (l < self.size() and self.max_heap.?.items[l] > self.max_heap.?.items[ma]) ma = l;
                 if (r < self.size() and self.max_heap.?.items[r] > self.max_heap.?.items[ma]) ma = r;
-                // 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
+                // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
                 if (ma == i) break;
                 // 交换两节点
                 try self.swap(i, ma);
diff --git a/codes/zig/chapter_tree/avl_tree.zig b/codes/zig/chapter_tree/avl_tree.zig
index cb90b756..767fc80e 100644
--- a/codes/zig/chapter_tree/avl_tree.zig
+++ b/codes/zig/chapter_tree/avl_tree.zig
@@ -103,7 +103,7 @@ pub fn AVLTree(comptime T: type) type {
                     return self.leftRotate(node);
                 }
             }
-            // 平衡树，无需旋转，直接返回
+            // 平衡树，无须旋转，直接返回
             return node;
         }
 
diff --git a/docs/chapter_appendix/installation.md b/docs/chapter_appendix/installation.md
index 23ad80fc..f96ea0a5 100644
--- a/docs/chapter_appendix/installation.md
+++ b/docs/chapter_appendix/installation.md
@@ -11,7 +11,7 @@
 
 ## C/C++ 环境
 
-1. Windows 系统需要安装 [MinGW](https://sourceforge.net/projects/mingw-w64/files/)（[配置教程](https://blog.csdn.net/qq_33698226/article/details/129031241)），MacOS 自带 Clang 无需安装。
+1. Windows 系统需要安装 [MinGW](https://sourceforge.net/projects/mingw-w64/files/)（[配置教程](https://blog.csdn.net/qq_33698226/article/details/129031241)），MacOS 自带 Clang 无须安装。
 2. 在 VSCode 的插件市场中搜索 `c++` ，安装 C/C++ Extension Pack 。
 3. （可选）打开 Settings 页面，搜索 `Clang_format_fallback Style` 代码格式化选项，设置为 `{ BasedOnStyle: Microsoft, BreakBeforeBraces: Attach }` 。
 
diff --git a/docs/chapter_array_and_linkedlist/array.md b/docs/chapter_array_and_linkedlist/array.md
index 86b8cab4..bc54714e 100755
--- a/docs/chapter_array_and_linkedlist/array.md
+++ b/docs/chapter_array_and_linkedlist/array.md
@@ -283,7 +283,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
 同理，如果我们想要删除索引 $i$ 处的元素，则需要把索引 $i$ 之后的元素都向前移动一位。
 
-请注意，删除元素完成后，原先末尾的元素变得“无意义”了，所以我们无需特意去修改它。
+请注意，删除元素完成后，原先末尾的元素变得“无意义”了，所以我们无须特意去修改它。
 
 ![数组删除元素](array.assets/array_remove_element.png)
 
@@ -601,7 +601,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
 数组存储在连续的内存空间内，且元素类型相同。这包含丰富的先验信息，系统可以利用这些信息来优化操作和运行效率，包括：
 
-- **空间效率高**: 数组为数据分配了连续的内存块，无需额外的结构开销。
+- **空间效率高**: 数组为数据分配了连续的内存块，无须额外的结构开销。
 - **支持随机访问**: 数组允许在 $O(1)$ 时间内访问任何元素。
 - **缓存局部性**: 当访问数组元素时，计算机不仅会加载它，还会缓存其周围的其他数据，从而借助高速缓存来提升后续操作的执行速度。
 
diff --git a/docs/chapter_array_and_linkedlist/linked_list.md b/docs/chapter_array_and_linkedlist/linked_list.md
index d83ff9a1..997036ab 100755
--- a/docs/chapter_array_and_linkedlist/linked_list.md
+++ b/docs/chapter_array_and_linkedlist/linked_list.md
@@ -2,7 +2,7 @@
 
 内存空间是所有程序的公共资源，在一个复杂的系统运行环境下，空闲的内存空间可能散落在内存各处。我们知道，存储数组的内存空间必须是连续的，而当数组非常大时，内存可能无法提供如此大的连续空间。此时链表的灵活性优势就体现出来了。
 
-「链表 Linked List」是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。引用记录了下一个节点的内存地址，我们可以通过它从当前节点访问到下一个节点。这意味着链表的各个节点可以被分散存储在内存各处，它们的内存地址是无需连续的。
+「链表 Linked List」是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。引用记录了下一个节点的内存地址，我们可以通过它从当前节点访问到下一个节点。这意味着链表的各个节点可以被分散存储在内存各处，它们的内存地址是无须连续的。
 
 ![链表定义与存储方式](linked_list.assets/linkedlist_definition.png)
 
diff --git a/docs/chapter_array_and_linkedlist/list.md b/docs/chapter_array_and_linkedlist/list.md
index 76fe0a2a..25a10bc1 100755
--- a/docs/chapter_array_and_linkedlist/list.md
+++ b/docs/chapter_array_and_linkedlist/list.md
@@ -2,7 +2,7 @@
 
 **数组长度不可变导致实用性降低**。在实际中，我们可能事先无法确定需要存储多少数据，这使数组长度的选择变得困难。若长度过小，需要在持续添加数据时频繁扩容数组；若长度过大，则会造成内存空间的浪费。
 
-为解决此问题，出现了一种被称为「动态数组 Dynamic Array」的数据结构，即长度可变的数组，也常被称为「列表 List」。列表基于数组实现，继承了数组的优点，并且可以在程序运行过程中动态扩容。我们可以在列表中自由地添加元素，而无需担心超过容量限制。
+为解决此问题，出现了一种被称为「动态数组 Dynamic Array」的数据结构，即长度可变的数组，也常被称为「列表 List」。列表基于数组实现，继承了数组的优点，并且可以在程序运行过程中动态扩容。我们可以在列表中自由地添加元素，而无须担心超过容量限制。
 
 ## 列表常用操作
 
diff --git a/docs/chapter_array_and_linkedlist/summary.md b/docs/chapter_array_and_linkedlist/summary.md
index 4d676d43..6c5b8dcb 100644
--- a/docs/chapter_array_and_linkedlist/summary.md
+++ b/docs/chapter_array_and_linkedlist/summary.md
@@ -55,7 +55,7 @@
 
     假如把列表元素换成链表节点 `n = [n1, n2, n3, n4, n5]` ，通常情况下这五个节点对象也是被分散存储在内存各处的。然而，给定一个列表索引，我们仍然可以在 $O(1)$ 时间内获取到节点内存地址，从而访问到对应的节点。这是因为数组中存储的是节点的引用，而非节点本身。
 
-    与许多语言不同的是，在 Python 中数字也被包装为对象，列表中存储的不是数字本身，而是对数字的引用。因此，我们会发现两个数组中的相同数字拥有同一个 id ，并且这些数字的内存地址是无需连续的。
+    与许多语言不同的是，在 Python 中数字也被包装为对象，列表中存储的不是数字本身，而是对数字的引用。因此，我们会发现两个数组中的相同数字拥有同一个 id ，并且这些数字的内存地址是无须连续的。
 
 !!! question "C++ STL 里面的 std::list 已经实现了双向链表，但好像一些算法的书上都不怎么直接用这个，是不是有什么局限性呢?"
 
diff --git a/docs/chapter_backtracking/subset_sum_problem.md b/docs/chapter_backtracking/subset_sum_problem.md
index bc87d056..fb1d99bd 100644
--- a/docs/chapter_backtracking/subset_sum_problem.md
+++ b/docs/chapter_backtracking/subset_sum_problem.md
@@ -15,7 +15,7 @@
 
 类似于全排列问题，我们可以把子集的生成过程想象成一系列选择的结果，并在选择过程中实时更新“元素和”，当元素和等于 `target` 时，就将子集记录至结果列表。
 
-而与全排列问题不同的是，**本题集合中的元素可以被无限次选取**，因此无需借助 `selected` 布尔列表来记录元素是否已被选择。我们可以对全排列代码进行小幅修改，初步得到解题代码。
+而与全排列问题不同的是，**本题集合中的元素可以被无限次选取**，因此无须借助 `selected` 布尔列表来记录元素是否已被选择。我们可以对全排列代码进行小幅修改，初步得到解题代码。
 
 === "Java"
 
diff --git a/docs/chapter_computational_complexity/index.md b/docs/chapter_computational_complexity/index.md
index e302bc56..274a680e 100644
--- a/docs/chapter_computational_complexity/index.md
+++ b/docs/chapter_computational_complexity/index.md
@@ -8,6 +8,6 @@
 
 !!! abstract
 
-    复杂度犹如浩瀚的算法宇宙中的指南针。
+    复杂度犹如浩瀚的算法宇宙中的时空向导。
     
-    它引导我们在时间与空间的维度上深入探索，寻找更优雅的解决方案。
+    它带领我们在时间与空间这两个维度上深入探索，寻找更优雅的解决方案。
diff --git a/docs/chapter_computational_complexity/performance_evaluation.md b/docs/chapter_computational_complexity/performance_evaluation.md
index a73f4aed..a5e3cbe6 100644
--- a/docs/chapter_computational_complexity/performance_evaluation.md
+++ b/docs/chapter_computational_complexity/performance_evaluation.md
@@ -1,11 +1,11 @@
 # 算法效率评估
 
-在算法设计中，我们先后追求以下两个层面的目标：
+在算法设计中，我们先后追求以下两个层面的目标。
 
 1. **找到问题解法**：算法需要在规定的输入范围内，可靠地求得问题的正确解。
 2. **寻求最优解法**：同一个问题可能存在多种解法，我们希望找到尽可能高效的算法。
 
-因此在能够解决问题的前提下，算法效率成为主要的评价维度，包括：
+因此，在能够解决问题的前提下，算法效率已成为衡量算法优劣的主要评价指标，它包括以下两个维度。
 
 - **时间效率**：算法运行速度的快慢。
 - **空间效率**：算法占用内存空间的大小。
@@ -18,28 +18,28 @@
 
 假设我们现在有算法 `A` 和算法 `B` ，它们都能解决同一问题，现在需要对比这两个算法的效率。最直接的方法是找一台计算机，运行这两个算法，并监控记录它们的运行时间和内存占用情况。这种评估方式能够反映真实情况，但也存在较大局限性。
 
-**难以排除测试环境的干扰因素**。硬件配置会影响算法的性能表现。比如在某台计算机中，算法 `A` 的运行时间比算法 `B` 短；但在另一台配置不同的计算机中，我们可能得到相反的测试结果。这意味着我们需要在各种机器上进行测试，统计平均效率，而这是不现实的。
+一方面，**难以排除测试环境的干扰因素**。硬件配置会影响算法的性能表现。比如在某台计算机中，算法 `A` 的运行时间比算法 `B` 短；但在另一台配置不同的计算机中，我们可能得到相反的测试结果。这意味着我们需要在各种机器上进行测试，统计平均效率，而这是不现实的。
 
-**展开完整测试非常耗费资源**。随着输入数据量的变化，算法会表现出不同的效率。例如，在输入数据量较小时，算法 `A` 的运行时间比算法 `B` 更少；而输入数据量较大时，测试结果可能恰恰相反。因此，为了得到有说服力的结论，我们需要测试各种规模的输入数据，而这样需要耗费大量的计算资源。
+另一方面，**展开完整测试非常耗费资源**。随着输入数据量的变化，算法会表现出不同的效率。例如，在输入数据量较小时，算法 `A` 的运行时间比算法 `B` 更少；而输入数据量较大时，测试结果可能恰恰相反。因此，为了得到有说服力的结论，我们需要测试各种规模的输入数据，而这样需要耗费大量的计算资源。
 
 ## 理论估算
 
-由于实际测试具有较大的局限性，我们可以考虑仅通过一些计算来评估算法的效率。这种估算方法被称为「渐近复杂度分析 Asymptotic Complexity Analysis」，简称为「复杂度分析」。
+由于实际测试具有较大的局限性，我们可以考虑仅通过一些计算来评估算法的效率。这种估算方法被称为「渐近复杂度分析 asymptotic complexity analysis」，简称「复杂度分析」。
 
-复杂度分析评估的是算法执行所需的时间和空间资源。**它被表示为一个函数，描述了随着输入数据大小的增加，算法所需时间（空间）的增长趋势**。这个定义有些拗口，我们可以将其分为三个重点来理解：
+复杂度分析评估的是算法运行所需的时间和空间资源，**它描述了随着输入数据大小的增加，算法所需时间（空间）的增长趋势**。这个定义有些拗口，我们可以将其分为三个重点来理解。
 
-1. “时间（空间）”分别对应「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。
+1. “时间和空间资源”分别对应「时间复杂度 time complexity」和「空间复杂度 space complexity」。
 2. “随着输入数据大小的增加”意味着复杂度反映了算法运行效率与输入数据体量之间的关系。
 3. “增长趋势”表示复杂度分析关注的是算法时间与空间的增长趋势，而非具体的运行时间或占用空间。
 
 **复杂度分析克服了实际测试方法的弊端**。首先，它独立于测试环境，分析结果适用于所有运行平台。其次，它可以体现不同数据量下的算法效率，尤其是在大数据量下的算法性能。
 
-如果你对复杂度分析的概念仍感到困惑，无需担心，我们会在后续章节详细介绍。
+如果你对复杂度分析的概念仍感到困惑，无须担心，我们会在后续章节中详细介绍。
 
 ## 复杂度的重要性
 
 复杂度分析为我们提供了一把评估算法效率的“标尺”，帮助我们衡量了执行某个算法所需的时间和空间资源，并使我们能够对比不同算法之间的效率。
 
-复杂度是个数学概念，对于初学者可能比较抽象，学习难度相对较高。从这个角度看，复杂度分析可能不太适合作为第一章的内容。
+复杂度是个数学概念，对于初学者可能比较抽象，学习难度相对较高。从这个角度看，复杂度分析可能不太适合作为第 1 章的内容。
 
-然而，当我们讨论某个数据结构或算法的特点时，难以避免要分析其运行速度和空间使用情况。因此，在深入学习数据结构与算法之前，**建议你先对复杂度建立初步的了解，能够完成简单算法的复杂度分析**。
+然而，当我们讨论某个数据结构或算法的特点时，难以避免要分析其运行速度和空间使用情况。因此，在深入学习数据结构与算法之前，**建议你先对复杂度建立初步的了解，以便能够完成简单算法的复杂度分析**。
diff --git a/docs/chapter_computational_complexity/space_complexity.md b/docs/chapter_computational_complexity/space_complexity.md
index 5c56c881..95cef5f8 100755
--- a/docs/chapter_computational_complexity/space_complexity.md
+++ b/docs/chapter_computational_complexity/space_complexity.md
@@ -1,24 +1,24 @@
 # 空间复杂度
 
-「空间复杂度 Space Complexity」用于衡量算法占用内存空间随着数据量变大时的增长趋势。这个概念与时间复杂度非常类似，只需将“运行时间”替换为“占用内存空间”。
+「空间复杂度 space complexity」用于衡量算法占用内存空间随着数据量变大时的增长趋势。这个概念与时间复杂度非常类似，只需将“运行时间”替换为“占用内存空间”。
 
 ## 算法相关空间
 
-算法运行过程中使用的内存空间主要包括以下几种：
+算法在运行过程中使用的内存空间主要包括以下几种。
 
 - **输入空间**：用于存储算法的输入数据。
-- **暂存空间**：用于存储算法运行过程中的变量、对象、函数上下文等数据。
+- **暂存空间**：用于存储算法在运行过程中的变量、对象、函数上下文等数据。
 - **输出空间**：用于存储算法的输出数据。
 
 一般情况下，空间复杂度的统计范围是“暂存空间”加上“输出空间”。
 
-暂存空间可以进一步划分为三个部分：
+暂存空间可以进一步划分为三个部分。
 
 - **暂存数据**：用于保存算法运行过程中的各种常量、变量、对象等。
 - **栈帧空间**：用于保存调用函数的上下文数据。系统在每次调用函数时都会在栈顶部创建一个栈帧，函数返回后，栈帧空间会被释放。
 - **指令空间**：用于保存编译后的程序指令，在实际统计中通常忽略不计。
 
-因此在分析一段程序的空间复杂度时，**我们通常统计暂存数据、输出数据、栈帧空间三部分**。
+在分析一段程序的空间复杂度时，**我们通常统计暂存数据、栈帧空间和输出数据三部分**。
 
 ![算法使用的相关空间](space_complexity.assets/space_types.png)
 
@@ -288,7 +288,7 @@
 
 ## 推算方法
 
-空间复杂度的推算方法与时间复杂度大致相同，只需将统计对象从“计算操作数量”转为“使用空间大小”。
+空间复杂度的推算方法与时间复杂度大致相同，只需将统计对象从“操作数量”转为“使用空间大小”。
 
 而与时间复杂度不同的是，**我们通常只关注「最差空间复杂度」**。这是因为内存空间是一项硬性要求，我们必须确保在所有输入数据下都有足够的内存空间预留。
 
@@ -426,7 +426,7 @@
 
     ```
 
-**在递归函数中，需要注意统计栈帧空间**。例如以下代码：
+**在递归函数中，需要注意统计栈帧空间**。例如在以下代码中：
 
 - 函数 `loop()` 在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。
 - 递归函数 `recur()` 在运行过程中会同时存在 $n$ 个未返回的 `recur()` ，从而占用 $O(n)$ 的栈帧空间。
@@ -652,7 +652,7 @@
 
 ## 常见类型
 
-设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）：
+设输入数据大小为 $n$ ，下图展示了常见的空间复杂度类型（从低到高排列）。
 
 $$
 \begin{aligned}
@@ -661,17 +661,17 @@ O(1) < O(\log n) < O(n) < O(n^2) < O(2^n) \newline
 \end{aligned}
 $$
 
-![空间复杂度的常见类型](space_complexity.assets/space_complexity_common_types.png)
+![常见的空间复杂度类型](space_complexity.assets/space_complexity_common_types.png)
 
 !!! tip
 
-    部分示例代码需要一些前置知识，包括数组、链表、二叉树、递归算法等。如果你遇到看不懂的地方，可以在学习完后面章节后再来复习。
+    部分示例代码需要一些前置知识，包括数组、链表、二叉树、递归算法等。如果你遇到看不懂的地方，可以在学完后面章节后再来复习。
 
 ### 常数阶 $O(1)$
 
 常数阶常见于数量与输入数据大小 $n$ 无关的常量、变量、对象。
 
-需要注意的是，在循环中初始化变量或调用函数而占用的内存，在进入下一循环后就会被释放，即不会累积占用空间，空间复杂度仍为 $O(1)$ 。
+需要注意的是，在循环中初始化变量或调用函数而占用的内存，在进入下一循环后就会被释放，即不会累积占用空间，空间复杂度仍为 $O(1)$ ：
 
 === "Java"
 
@@ -771,7 +771,7 @@ $$
 
 ### 线性阶 $O(n)$
 
-线性阶常见于元素数量与 $n$ 成正比的数组、链表、栈、队列等。
+线性阶常见于元素数量与 $n$ 成正比的数组、链表、栈、队列等：
 
 === "Java"
 
@@ -847,7 +847,7 @@ $$
     [class]{}-[func]{linear}
     ```
 
-以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间。
+以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间：
 
 === "Java"
 
@@ -925,7 +925,7 @@ $$
 
 ### 平方阶 $O(n^2)$
 
-平方阶常见于矩阵和图，元素数量与 $n$ 成平方关系。
+平方阶常见于矩阵和图，元素数量与 $n$ 成平方关系：
 
 === "Java"
 
@@ -1077,7 +1077,7 @@ $$
 
 ### 指数阶 $O(2^n)$
 
-指数阶常见于二叉树。高度为 $n$ 的「满二叉树」的节点数量为 $2^n - 1$ ，占用 $O(2^n)$ 空间。
+指数阶常见于二叉树。高度为 $n$ 的「满二叉树」的节点数量为 $2^n - 1$ ，占用 $O(2^n)$ 空间：
 
 === "Java"
 
@@ -1157,9 +1157,9 @@ $$
 
 对数阶常见于分治算法和数据类型转换等。
 
-例如“归并排序”算法，输入长度为 $n$ 的数组，每轮递归将数组从中点划分为两半，形成高度为 $\log n$ 的递归树，使用 $O(\log n)$ 栈帧空间。
+例如归并排序算法，输入长度为 $n$ 的数组，每轮递归将数组从中点划分为两半，形成高度为 $\log n$ 的递归树，使用 $O(\log n)$ 栈帧空间。
 
-再例如“数字转化为字符串”，输入任意正整数 $n$ ，它的位数为 $\log_{10} n$ ，即对应字符串长度为 $\log_{10} n$ ，因此空间复杂度为 $O(\log_{10} n) = O(\log n)$ 。
+再例如将数字转化为字符串，输入任意正整数 $n$ ，它的位数为 $\log_{10} n + 1$ ，即对应字符串长度为 $\log_{10} n + 1$ ，因此空间复杂度为 $O(\log_{10} n + 1) = O(\log n)$ 。
 
 ## 权衡时间与空间
 
@@ -1167,4 +1167,4 @@ $$
 
 **降低时间复杂度通常需要以提升空间复杂度为代价，反之亦然**。我们将牺牲内存空间来提升算法运行速度的思路称为“以空间换时间”；反之，则称为“以时间换空间”。
 
-选择哪种思路取决于我们更看重哪个方面。在大多数情况下，时间比空间更宝贵，因此以空间换时间通常是更常用的策略。当然，在数据量很大的情况下，控制空间复杂度也是非常重要的。
+选择哪种思路取决于我们更看重哪个方面。在大多数情况下，时间比空间更宝贵，因此“以空间换时间”通常是更常用的策略。当然，在数据量很大的情况下，控制空间复杂度也是非常重要的。
diff --git a/docs/chapter_computational_complexity/summary.md b/docs/chapter_computational_complexity/summary.md
index cc0f402f..608fdf20 100644
--- a/docs/chapter_computational_complexity/summary.md
+++ b/docs/chapter_computational_complexity/summary.md
@@ -2,45 +2,45 @@
 
 **算法效率评估**
 
-- 时间效率和空间效率是评价算法性能的两个关键维度。
+- 时间效率和空间效率是衡量算法优劣的两个主要评价指标。
 - 我们可以通过实际测试来评估算法效率，但难以消除测试环境的影响，且会耗费大量计算资源。
 - 复杂度分析可以克服实际测试的弊端，分析结果适用于所有运行平台，并且能够揭示算法在不同数据规模下的效率。
 
 **时间复杂度**
 
-- 时间复杂度用于衡量算法运行时间随数据量增长的趋势，可以有效评估算法效率，但在某些情况下可能失效，如在输入数据量较小或时间复杂度相同时，无法精确对比算法效率的优劣。
-- 最差时间复杂度使用大 $O$ 符号表示，即函数渐近上界，反映当 $n$ 趋向正无穷时，$T(n)$ 的增长级别。
-- 推算时间复杂度分为两步，首先统计计算操作数量，然后判断渐近上界。
-- 常见时间复杂度从小到大排列有 $O(1)$ , $O(\log n)$ , $O(n)$ , $O(n \log n)$ , $O(n^2)$ , $O(2^n)$ , $O(n!)$ 等。
+- 时间复杂度用于衡量算法运行时间随数据量增长的趋势，可以有效评估算法效率，但在某些情况下可能失效，如在输入的数据量较小或时间复杂度相同时，无法精确对比算法效率的优劣。
+- 最差时间复杂度使用大 $O$ 符号表示，对应函数渐近上界，反映当 $n$ 趋向正无穷时，操作数量 $T(n)$ 的增长级别。
+- 推算时间复杂度分为两步，首先统计操作数量，然后判断渐近上界。
+- 常见时间复杂度从小到大排列有 $O(1)$ 、$O(\log n)$ 、$O(n)$ 、$O(n \log n)$ 、$O(n^2)$ 、$O(2^n)$ 、$O(n!)$ 等。
 - 某些算法的时间复杂度非固定，而是与输入数据的分布有关。时间复杂度分为最差、最佳、平均时间复杂度，最佳时间复杂度几乎不用，因为输入数据一般需要满足严格条件才能达到最佳情况。
 - 平均时间复杂度反映算法在随机数据输入下的运行效率，最接近实际应用中的算法性能。计算平均时间复杂度需要统计输入数据分布以及综合后的数学期望。
 
 **空间复杂度**
 
-- 类似于时间复杂度，空间复杂度用于衡量算法占用空间随数据量增长的趋势。
+- 空间复杂度的作用类似于时间复杂度，用于衡量算法占用空间随数据量增长的趋势。
 - 算法运行过程中的相关内存空间可分为输入空间、暂存空间、输出空间。通常情况下，输入空间不计入空间复杂度计算。暂存空间可分为指令空间、数据空间、栈帧空间，其中栈帧空间通常仅在递归函数中影响空间复杂度。
 - 我们通常只关注最差空间复杂度，即统计算法在最差输入数据和最差运行时间点下的空间复杂度。
-- 常见空间复杂度从小到大排列有 $O(1)$ , $O(\log n)$ , $O(n)$ , $O(n^2)$ , $O(2^n)$ 等。
+- 常见空间复杂度从小到大排列有 $O(1)$ 、$O(\log n)$ 、$O(n)$ 、$O(n^2)$ 、$O(2^n)$ 等。
 
 ## Q & A
 
 !!! question "尾递归的空间复杂度是 $O(1)$ 吗？"
 
-    理论上，尾递归函数的空间复杂度可以被优化至 $O(1)$ 。不过绝大多数编程语言（例如 Java, Python, C++, Go, C# 等）都不支持自动优化尾递归，因此通常认为空间复杂度是 $O(n)$ 。
+    理论上，尾递归函数的空间复杂度可以被优化至 $O(1)$ 。不过绝大多数编程语言（例如 Java 、Python 、C++ 、Go 、C# 等）都不支持自动优化尾递归，因此通常认为空间复杂度是 $O(n)$ 。
 
 !!! question "函数和方法这两个术语的区别是什么？"
 
-    函数（function）可以独立被执行，所有参数都以显式传递。方法（method）与一个对象关联，方法被隐式传递给调用它的对象，方法能够对类的实例中包含的数据进行操作。
+    函数（function）可以被独立执行，所有参数都以显式传递。方法（method）与一个对象关联，被隐式传递给调用它的对象，能够对类的实例中包含的数据进行操作。
 
-    以几个常见的编程语言为例：
+    下面以几个常见的编程语言来说明。
 
-    - C 语言是过程式编程语言，没有面向对象的概念，所以只有函数。但我们可以通过创建结构（struct）来模拟面向对象编程，与结构体相关联的函数就相当于其他语言中的方法。
-    - Java, C# 是面向对象的编程语言，代码块（方法）通常都是作为某个类的一部分。静态方法的行为类似于函数，因为它被绑定在类上，不能访问特定的实例变量。
-    - C++, Python 既支持过程式编程（函数）也支持面向对象编程（方法）。
+    - C 语言是过程式编程语言，没有面向对象的概念，所以只有函数。但我们可以通过创建结构体（struct）来模拟面向对象编程，与结构体相关联的函数就相当于其他语言中的方法。
+    - Java 和 C# 是面向对象的编程语言，代码块（方法）通常都是作为某个类的一部分。静态方法的行为类似于函数，因为它被绑定在类上，不能访问特定的实例变量。
+    - C++ 和 Python 既支持过程式编程（函数），也支持面向对象编程（方法）。
 
-!!! question "图片“空间复杂度的常见类型”反映的是否是占用空间的绝对大小？"
+!!! question "图“空间复杂度的常见类型”反映的是否是占用空间的绝对大小？"
 
-    不是，该图片展示的是空间复杂度，其反映的是即增长趋势，而不是占用空间的绝对大小。
+    不是，该图片展示的是空间复杂度，其反映的是增长趋势，而不是占用空间的绝对大小。
     
     假设取 $n = 8$ ，你可能会发现每条曲线的值与函数对应不上。这是因为每条曲线都包含一个常数项，用于将取值范围压缩到一个视觉舒适的范围内。
 
diff --git a/docs/chapter_computational_complexity/time_complexity.md b/docs/chapter_computational_complexity/time_complexity.md
index 8b4cff5c..8f384070 100755
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -3,14 +3,10 @@
 运行时间可以直观且准确地反映算法的效率。如果我们想要准确预估一段代码的运行时间，应该如何操作呢？
 
 1. **确定运行平台**，包括硬件配置、编程语言、系统环境等，这些因素都会影响代码的运行效率。
-2. **评估各种计算操作所需的运行时间**，例如加法操作 `+` 需要 1 ns，乘法操作 `*` 需要 10 ns，打印操作需要 5 ns 等。
+2. **评估各种计算操作所需的运行时间**，例如加法操作 `+` 需要 1 ns，乘法操作 `*` 需要 10 ns，打印操作 `print()` 需要 5 ns 等。
 3. **统计代码中所有的计算操作**，并将所有操作的执行时间求和，从而得到运行时间。
 
-例如以下代码，输入数据大小为 $n$ 。根据以上方法，可以得到算法运行时间为 $6n + 12$ ns 。
-
-$$
-1 + 1 + 10 + (1 + 5) \times n = 6n + 12
-$$
+例如在以下代码中，输入数据大小为 $n$ ：
 
 === "Java"
 
@@ -181,28 +177,34 @@ $$
     }
     ```
 
-但实际上，**统计算法的运行时间既不合理也不现实**。首先，我们不希望预估时间和运行平台绑定，因为算法需要在各种不同的平台上运行。其次，我们很难获知每种操作的运行时间，这给预估过程带来了极大的难度。
+根据以上方法，可以得到算法运行时间为 $6n + 12$ ns ：
+
+$$
+1 + 1 + 10 + (1 + 5) \times n = 6n + 12
+$$
+
+但实际上，**统计算法的运行时间既不合理也不现实**。首先，我们不希望将预估时间和运行平台绑定，因为算法需要在各种不同的平台上运行。其次，我们很难获知每种操作的运行时间，这给预估过程带来了极大的难度。
 
 ## 统计时间增长趋势
 
 「时间复杂度分析」采取了一种不同的方法，其统计的不是算法运行时间，**而是算法运行时间随着数据量变大时的增长趋势**。
 
-“时间增长趋势”这个概念比较抽象，我们通过一个例子来加以理解。假设输入数据大小为 $n$ ，给定三个算法函数 `A` , `B` , `C` 。
+“时间增长趋势”这个概念比较抽象，我们通过一个例子来加以理解。假设输入数据大小为 $n$ ，给定三个算法函数 `A` 、 `B` 和 `C` ：
 
 === "Java"
 
     ```java title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     void algorithm_A(int n) {
         System.out.println(0);
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     void algorithm_B(int n) {
         for (int i = 0; i < n; i++) {
             System.out.println(0);
         }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     void algorithm_C(int n) {
         for (int i = 0; i < 1000000; i++) {
             System.out.println(0);
@@ -213,17 +215,17 @@ $$
 === "C++"
 
     ```cpp title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     void algorithm_A(int n) {
         cout << 0 << endl;
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     void algorithm_B(int n) {
         for (int i = 0; i < n; i++) {
             cout << 0 << endl;
         }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     void algorithm_C(int n) {
         for (int i = 0; i < 1000000; i++) {
             cout << 0 << endl;
@@ -234,14 +236,14 @@ $$
 === "Python"
 
     ```python title=""
-    # 算法 A 时间复杂度：常数阶
+    # 算法 A 的时间复杂度：常数阶
     def algorithm_A(n: int):
         print(0)
-    # 算法 B 时间复杂度：线性阶
+    # 算法 B 的时间复杂度：线性阶
     def algorithm_B(n: int):
         for _ in range(n):
             print(0)
-    # 算法 C 时间复杂度：常数阶
+    # 算法 C 的时间复杂度：常数阶
     def algorithm_C(n: int):
         for _ in range(1000000):
             print(0)
@@ -250,17 +252,17 @@ $$
 === "Go"
 
     ```go title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     func algorithm_A(n int) {
         fmt.Println(0)
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     func algorithm_B(n int) {
         for i := 0; i < n; i++ {
             fmt.Println(0)
         }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     func algorithm_C(n int) {
         for i := 0; i < 1000000; i++ {
             fmt.Println(0)
@@ -271,17 +273,17 @@ $$
 === "JS"
 
     ```javascript title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     function algorithm_A(n) {
         console.log(0);
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     function algorithm_B(n) {
         for (let i = 0; i < n; i++) {
             console.log(0);
         }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     function algorithm_C(n) {
         for (let i = 0; i < 1000000; i++) {
             console.log(0);
@@ -293,17 +295,17 @@ $$
 === "TS"
 
     ```typescript title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     function algorithm_A(n: number): void {
         console.log(0);
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     function algorithm_B(n: number): void {
         for (let i = 0; i < n; i++) {
             console.log(0);
         }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     function algorithm_C(n: number): void {
         for (let i = 0; i < 1000000; i++) {
             console.log(0);
@@ -314,17 +316,17 @@ $$
 === "C"
 
     ```c title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     void algorithm_A(int n) {
         printf("%d", 0);
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     void algorithm_B(int n) {
         for (int i = 0; i < n; i++) {
             printf("%d", 0);
         }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     void algorithm_C(int n) {
         for (int i = 0; i < 1000000; i++) {
             printf("%d", 0);
@@ -335,17 +337,17 @@ $$
 === "C#"
 
     ```csharp title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     void algorithm_A(int n) {
         Console.WriteLine(0);
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     void algorithm_B(int n) {
         for (int i = 0; i < n; i++) {
             Console.WriteLine(0);
         }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     void algorithm_C(int n) {
         for (int i = 0; i < 1000000; i++) {
             Console.WriteLine(0);
@@ -356,19 +358,19 @@ $$
 === "Swift"
 
     ```swift title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     func algorithmA(n: Int) {
         print(0)
     }
 
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     func algorithmB(n: Int) {
         for _ in 0 ..< n {
             print(0)
         }
     }
 
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     func algorithmC(n: Int) {
         for _ in 0 ..< 1000000 {
             print(0)
@@ -385,17 +387,17 @@ $$
 === "Dart"
 
     ```dart title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     void algorithmA(int n) {
       print(0);
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     void algorithmB(int n) {
       for (int i = 0; i < n; i++) {
         print(0);
       }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     void algorithmC(int n) {
       for (int i = 0; i < 1000000; i++) {
         print(0);
@@ -406,17 +408,17 @@ $$
 === "Rust"
 
     ```rust title=""
-    // 算法 A 时间复杂度：常数阶
+    // 算法 A 的时间复杂度：常数阶
     fn algorithm_A(n: i32) {
         println!("{}", 0);
     }
-    // 算法 B 时间复杂度：线性阶
+    // 算法 B 的时间复杂度：线性阶
     fn algorithm_B(n: i32) {
         for _ in 0..n {
             println!("{}", 0);
         }
     }
-    // 算法 C 时间复杂度：常数阶
+    // 算法 C 的时间复杂度：常数阶
     fn algorithm_C(n: i32) {
         for _ in 0..1000000 {
             println!("{}", 0);
@@ -430,19 +432,17 @@ $$
 
 算法 `C` 中的打印操作需要循环 $1000000$ 次，虽然运行时间很长，但它与输入数据大小 $n$ 无关。因此 `C` 的时间复杂度和 `A` 相同，仍为「常数阶」。
 
-![算法 A, B, C 的时间增长趋势](time_complexity.assets/time_complexity_simple_example.png)
+![算法 A 、B 和 C 的时间增长趋势](time_complexity.assets/time_complexity_simple_example.png)
 
 相较于直接统计算法运行时间，时间复杂度分析有哪些特点呢？
 
-**时间复杂度能够有效评估算法效率**。例如，算法 `B` 的运行时间呈线性增长，在 $n > 1$ 时比算法 `A` 更慢，在 $n > 1000000$ 时比算法 `C` 更慢。事实上，只要输入数据大小 $n$ 足够大，复杂度为“常数阶”的算法一定优于“线性阶”的算法，这正是时间增长趋势所表达的含义。
-
-**时间复杂度的推算方法更简便**。显然，运行平台和计算操作类型都与算法运行时间的增长趋势无关。因此在时间复杂度分析中，我们可以简单地将所有计算操作的执行时间视为相同的“单位时间”，从而将“计算操作的运行时间的统计”简化为“计算操作的数量的统计”，这样以来估算难度就大大降低了。
-
-**时间复杂度也存在一定的局限性**。例如，尽管算法 `A` 和 `C` 的时间复杂度相同，但实际运行时间差别很大。同样，尽管算法 `B` 的时间复杂度比 `C` 高，但在输入数据大小 $n$ 较小时，算法 `B` 明显优于算法 `C` 。在这些情况下，我们很难仅凭时间复杂度判断算法效率高低。当然，尽管存在上述问题，复杂度分析仍然是评判算法效率最有效且常用的方法。
+- **时间复杂度能够有效评估算法效率**。例如，算法 `B` 的运行时间呈线性增长，在 $n > 1$ 时比算法 `A` 更慢，在 $n > 1000000$ 时比算法 `C` 更慢。事实上，只要输入数据大小 $n$ 足够大，复杂度为“常数阶”的算法一定优于“线性阶”的算法，这正是时间增长趋势所表达的含义。
+- **时间复杂度的推算方法更简便**。显然，运行平台和计算操作类型都与算法运行时间的增长趋势无关。因此在时间复杂度分析中，我们可以简单地将所有计算操作的执行时间视为相同的“单位时间”，从而将“计算操作的运行时间的统计”简化为“计算操作的数量的统计”，这样以来估算难度就大大降低了。
+- **时间复杂度也存在一定的局限性**。例如，尽管算法 `A` 和 `C` 的时间复杂度相同，但实际运行时间差别很大。同样，尽管算法 `B` 的时间复杂度比 `C` 高，但在输入数据大小 $n$ 较小时，算法 `B` 明显优于算法 `C` 。在这些情况下，我们很难仅凭时间复杂度判断算法效率的高低。当然，尽管存在上述问题，复杂度分析仍然是评判算法效率最有效且常用的方法。
 
 ## 函数渐近上界
 
-给定一个函数 `algorithm()` ：
+给定一个输入大小为 $n$ 的函数：
 
 === "Java"
 
@@ -603,15 +603,15 @@ $$
     }
     ```
 
-设算法的计算操作数量是一个关于输入数据大小 $n$ 的函数，记为 $T(n)$ ，则以上函数的的操作数量为：
+设算法的操作数量是一个关于输入数据大小 $n$ 的函数，记为 $T(n)$ ，则以上函数的的操作数量为：
 
 $$
 T(n) = 3 + 2n
 $$
 
-$T(n)$ 是一次函数，说明时间的增长趋势是线性的，因此其时间复杂度是线性阶。
+$T(n)$ 是一次函数，说明其运行时间的增长趋势是线性的，因此它的时间复杂度是线性阶。
 
-我们将线性阶的时间复杂度记为 $O(n)$ ，这个数学符号称为「大 $O$ 记号 Big-$O$ Notation」，表示函数 $T(n)$ 的「渐近上界 Asymptotic Upper Bound」。
+我们将线性阶的时间复杂度记为 $O(n)$ ，这个数学符号称为「大 $O$ 记号 big-$O$ notation」，表示函数 $T(n)$ 的「渐近上界 asymptotic upper bound」。
 
 时间复杂度分析本质上是计算“操作数量函数 $T(n)$”的渐近上界。接下来，我们来看函数渐近上界的数学定义。
 
@@ -626,25 +626,25 @@ $T(n)$ 是一次函数，说明时间的增长趋势是线性的，因此其时
     T(n) = O(f(n))
     $$
 
-![函数的渐近上界](time_complexity.assets/asymptotic_upper_bound.png)
+如下图所示，计算渐近上界就是寻找一个函数 $f(n)$ ，使得当 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别，仅相差一个常数项 $c$ 的倍数。
 
-也就是说，计算渐近上界就是寻找一个函数 $f(n)$ ，使得当 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别，仅相差一个常数项 $c$ 的倍数。
+![函数的渐近上界](time_complexity.assets/asymptotic_upper_bound.png)
 
 ## 推算方法
 
-渐近上界的数学味儿有点重，如果你感觉没有完全理解，也无需担心。因为在实际使用中，我们只需要掌握推算方法，数学意义可以逐渐领悟。
+渐近上界的数学味儿有点重，如果你感觉没有完全理解，也无须担心。因为在实际使用中，我们只需要掌握推算方法，数学意义就可以逐渐领悟。
 
 根据定义，确定 $f(n)$ 之后，我们便可得到时间复杂度 $O(f(n))$ 。那么如何确定渐近上界 $f(n)$ 呢？总体分为两步：首先统计操作数量，然后判断渐近上界。
 
 ### 第一步：统计操作数量
 
-针对代码，逐行从上到下计算即可。然而，由于上述 $c \cdot f(n)$ 中的常数项 $c$ 可以取任意大小，**因此操作数量 $T(n)$ 中的各种系数、常数项都可以被忽略**。根据此原则，可以总结出以下计数简化技巧：
+针对代码，逐行从上到下计算即可。然而，由于上述 $c \cdot f(n)$ 中的常数项 $c$ 可以取任意大小，**因此操作数量 $T(n)$ 中的各种系数、常数项都可以被忽略**。根据此原则，可以总结出以下计数简化技巧。
 
 1. **忽略 $T(n)$ 中的常数项**。因为它们都与 $n$ 无关，所以对时间复杂度不产生影响。
 2. **省略所有系数**。例如，循环 $2n$ 次、$5n + 1$ 次等，都可以简化记为 $n$ 次，因为 $n$ 前面的系数对时间复杂度没有影响。
 3. **循环嵌套时使用乘法**。总操作数量等于外层循环和内层循环操作数量之积，每一层循环依然可以分别套用上述 `1.` 和 `2.` 技巧。
 
-以下示例展示了使用上述技巧前、后的统计结果。两者推出的时间复杂度相同，即为 $O(n^2)$ 。
+以下代码与公式分别展示了使用上述技巧前后的统计结果。两者推出的时间复杂度相同，都为 $O(n^2)$ 。
 
 $$
 \begin{aligned}
@@ -872,7 +872,8 @@ $$
 **时间复杂度由多项式 $T(n)$ 中最高阶的项来决定**。这是因为在 $n$ 趋于无穷大时，最高阶的项将发挥主导作用，其他项的影响都可以被忽略。
 
 以下表格展示了一些例子，其中一些夸张的值是为了强调“系数无法撼动阶数”这一结论。当 $n$ 趋于无穷大时，这些常数变得无足轻重。
-<p align="center"> 表：多项式时间复杂度示例 </p>
+
+<p align="center"> 表：不同操作数量对应的时间复杂度 </p>
 
 | 操作数量 $T(n)$        | 时间复杂度 $O(f(n))$ |
 | ---------------------- | -------------------- |
@@ -893,17 +894,17 @@ O(1) < O(\log n) < O(n) < O(n \log n) < O(n^2) < O(2^n) < O(n!) \newline
 \end{aligned}
 $$
 
-![时间复杂度的常见类型](time_complexity.assets/time_complexity_common_types.png)
+![常见的时间复杂度类型](time_complexity.assets/time_complexity_common_types.png)
 
 !!! tip
 
-    部分示例代码需要一些预备知识，包括数组、递归等。如果你遇到不理解的部分，可以在学习完后面章节后再回顾。现阶段，请先专注于理解时间复杂度的含义和推算方法。
+    部分示例代码需要一些预备知识，包括数组、递归等。如果你遇到不理解的部分，可以在学完后面章节后再回顾。现阶段，请先专注于理解时间复杂度的含义和推算方法。
 
 ### 常数阶 $O(1)$
 
 常数阶的操作数量与输入数据大小 $n$ 无关，即不随着 $n$ 的变化而变化。
 
-对于以下算法，尽管操作数量 `size` 可能很大，但由于其与数据大小 $n$ 无关，因此时间复杂度仍为 $O(1)$ 。
+对于以下算法，尽管操作数量 `size` 可能很大，但由于其与输入数据大小 $n$ 无关，因此时间复杂度仍为 $O(1)$ ：
 
 === "Java"
 
@@ -979,7 +980,7 @@ $$
 
 ### 线性阶 $O(n)$
 
-线性阶的操作数量相对于输入数据大小以线性级别增长。线性阶通常出现在单层循环中。
+线性阶的操作数量相对于输入数据大小 $n$ 以线性级别增长。线性阶通常出现在单层循环中：
 
 === "Java"
 
@@ -1053,7 +1054,7 @@ $$
     [class]{}-[func]{linear}
     ```
 
-遍历数组和遍历链表等操作的时间复杂度均为 $O(n)$ ，其中 $n$ 为数组或链表的长度。
+遍历数组和遍历链表等操作的时间复杂度均为 $O(n)$ ，其中 $n$ 为数组或链表的长度：
 
 === "Java"
 
@@ -1127,11 +1128,11 @@ $$
     [class]{}-[func]{array_traversal}
     ```
 
-值得注意的是，**数据大小 $n$ 需根据输入数据的类型来具体确定**。比如在第一个示例中，变量 $n$ 为输入数据大小；在第二个示例中，数组长度 $n$ 为数据大小。
+值得注意的是，**输入数据大小 $n$ 需根据输入数据的类型来具体确定**。比如在第一个示例中，变量 $n$ 为输入数据大小；在第二个示例中，数组长度 $n$ 为数据大小。
 
 ### 平方阶 $O(n^2)$
 
-平方阶的操作数量相对于输入数据大小以平方级别增长。平方阶通常出现在嵌套循环中，外层循环和内层循环都为 $O(n)$ ，因此总体为 $O(n^2)$ 。
+平方阶的操作数量相对于输入数据大小以平方级别增长。平方阶通常出现在嵌套循环中，外层循环和内层循环都为 $O(n)$ ，因此总体为 $O(n^2)$ ：
 
 === "Java"
 
@@ -1205,9 +1206,11 @@ $$
     [class]{}-[func]{quadratic}
     ```
 
-![常数阶、线性阶、平方阶的时间复杂度](time_complexity.assets/time_complexity_constant_linear_quadratic.png)
+下图对比了常数阶、线性阶和平方阶三种时间复杂度。
 
-以「冒泡排序」为例，外层循环执行 $n - 1$ 次，内层循环执行 $n-1, n-2, \cdots, 2, 1$ 次，平均为 $\frac{n}{2}$ 次，因此时间复杂度为 $O(n^2)$ 。
+![常数阶、线性阶和平方阶的时间复杂度](time_complexity.assets/time_complexity_constant_linear_quadratic.png)
+
+以冒泡排序为例，外层循环执行 $n - 1$ 次，内层循环执行 $n-1, n-2, \cdots, 2, 1$ 次，平均为 $\frac{n}{2}$ 次，因此时间复杂度为 $O(n^2)$ ：
 
 $$
 O((n - 1) \frac{n}{2}) = O(n^2)
@@ -1287,9 +1290,7 @@ $$
 
 ### 指数阶 $O(2^n)$
 
-生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 $1$ 个细胞，分裂一轮后变为 $2$ 个，分裂两轮后变为 $4$ 个，以此类推，分裂 $n$ 轮后有 $2^n$ 个细胞。
-
-以下代码模拟了细胞分裂的过程。
+生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 $1$ 个细胞，分裂一轮后变为 $2$ 个，分裂两轮后变为 $4$ 个，以此类推，分裂 $n$ 轮后有 $2^n$ 个细胞。相关代码如下：
 
 === "Java"
 
@@ -1363,9 +1364,11 @@ $$
     [class]{}-[func]{exponential}
     ```
 
+下图展示了细胞分裂的过程。
+
 ![指数阶的时间复杂度](time_complexity.assets/time_complexity_exponential.png)
 
-在实际算法中，指数阶常出现于递归函数。例如以下代码，其递归地一分为二，经过 $n$ 次分裂后停止。
+在实际算法中，指数阶常出现于递归函数中。例如以下代码，其递归地一分为二，经过 $n$ 次分裂后停止：
 
 === "Java"
 
@@ -1443,7 +1446,7 @@ $$
 
 ### 对数阶 $O(\log n)$
 
-与指数阶相反，对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。
+与指数阶相反，对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。相关代码如下：
 
 === "Java"
 
@@ -1519,7 +1522,7 @@ $$
 
 ![对数阶的时间复杂度](time_complexity.assets/time_complexity_logarithmic.png)
 
-与指数阶类似，对数阶也常出现于递归函数。以下代码形成了一个高度为 $\log_2 n$ 的递归树。
+与指数阶类似，对数阶也常出现于递归函数中。以下代码形成了一个高度为 $\log_2 n$ 的递归树：
 
 === "Java"
 
@@ -1593,13 +1596,11 @@ $$
     [class]{}-[func]{log_recur}
     ```
 
-对数阶常出现于基于「分治」的算法中，体现了“一分为多”和“化繁为简”的算法思想。它增长缓慢，是理想的时间复杂度，仅次于常数阶。
+对数阶常出现于基于分治策略的算法中，体现了“一分为多”和“化繁为简”的算法思想。它增长缓慢，是理想的时间复杂度，仅次于常数阶。
 
 ### 线性对数阶 $O(n \log n)$
 
-线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 $O(\log n)$ 和 $O(n)$ 。
-
-主流排序算法的时间复杂度通常为 $O(n \log n)$ ，例如快速排序、归并排序、堆排序等。
+线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 $O(\log n)$ 和 $O(n)$ 。相关代码如下：
 
 === "Java"
 
@@ -1675,6 +1676,8 @@ $$
 
 ![线性对数阶的时间复杂度](time_complexity.assets/time_complexity_logarithmic_linear.png)
 
+主流排序算法的时间复杂度通常为 $O(n \log n)$ ，例如快速排序、归并排序、堆排序等。
+
 ### 阶乘阶 $O(n!)$
 
 阶乘阶对应数学上的“全排列”问题。给定 $n$ 个互不重复的元素，求其所有可能的排列方案，方案数量为：
@@ -1683,7 +1686,7 @@ $$
 n! = n \times (n - 1) \times (n - 2) \times \cdots \times 2 \times 1
 $$
 
-阶乘通常使用递归实现。例如以下代码，第一层分裂出 $n$ 个，第二层分裂出 $n - 1$ 个，以此类推，直至第 $n$ 层时终止分裂。
+阶乘通常使用递归实现。例如在以下代码中，第一层分裂出 $n$ 个，第二层分裂出 $n - 1$ 个，以此类推，直至第 $n$ 层时停止分裂：
 
 === "Java"
 
@@ -1759,16 +1762,16 @@ $$
 
 ![阶乘阶的时间复杂度](time_complexity.assets/time_complexity_factorial.png)
 
-请注意，因为 $n! > 2^n$ ，所以阶乘阶比指数阶增长地更快，在 $n$ 较大时也是不可接受的。
+请注意，因为 $n! > 2^n$ ，所以阶乘阶比指数阶增长得更快，在 $n$ 较大时也是不可接受的。
 
 ## 最差、最佳、平均时间复杂度
 
-**算法的时间效率往往不是固定的，而是与输入数据的分布有关**。假设输入一个长度为 $n$ 的数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的，任务目标是返回元素 $1$ 的索引。我们可以得出以下结论：
+**算法的时间效率往往不是固定的，而是与输入数据的分布有关**。假设输入一个长度为 $n$ 的数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，每个数字只出现一次，但元素顺序是随机打乱的，任务目标是返回元素 $1$ 的索引。我们可以得出以下结论。
 
 - 当 `nums = [?, ?, ..., 1]` ，即当末尾元素是 $1$ 时，需要完整遍历数组，**达到最差时间复杂度 $O(n)$** 。
-- 当 `nums = [1, ?, ?, ...]` ，即当首个数字为 $1$ 时，无论数组多长都不需要继续遍历，**达到最佳时间复杂度 $\Omega(1)$** 。
+- 当 `nums = [1, ?, ?, ...]` ，即当首个元素为 $1$ 时，无论数组多长都不需要继续遍历，**达到最佳时间复杂度 $\Omega(1)$** 。
 
-「最差时间复杂度」对应函数渐近上界，使用大 $O$ 记号表示。相应地，「最佳时间复杂度」对应函数渐近下界，用 $\Omega$ 记号表示。
+「最差时间复杂度」对应函数渐近上界，使用大 $O$ 记号表示。相应地，「最佳时间复杂度」对应函数渐近下界，用 $\Omega$ 记号表示：
 
 === "Java"
 
@@ -1889,10 +1892,10 @@ $$
 
 从上述示例可以看出，最差或最佳时间复杂度只出现于“特殊的数据分布”，这些情况的出现概率可能很小，并不能真实地反映算法运行效率。相比之下，**「平均时间复杂度」可以体现算法在随机输入数据下的运行效率**，用 $\Theta$ 记号来表示。
 
-对于部分算法，我们可以简单地推算出随机数据分布下的平均情况。比如上述示例，由于输入数组是被打乱的，因此元素 $1$ 出现在任意索引的概率都是相等的，那么算法的平均循环次数则是数组长度的一半 $\frac{n}{2}$ ，平均时间复杂度为 $\Theta(\frac{n}{2}) = \Theta(n)$ 。
+对于部分算法，我们可以简单地推算出随机数据分布下的平均情况。比如上述示例，由于输入数组是被打乱的，因此元素 $1$ 出现在任意索引的概率都是相等的，那么算法的平均循环次数就是数组长度的一半 $\frac{n}{2}$ ，平均时间复杂度为 $\Theta(\frac{n}{2}) = \Theta(n)$ 。
 
 但对于较为复杂的算法，计算平均时间复杂度往往是比较困难的，因为很难分析出在数据分布下的整体数学期望。在这种情况下，我们通常使用最差时间复杂度作为算法效率的评判标准。
 
 !!! question "为什么很少看到 $\Theta$ 符号？"
 
-    可能由于 $O$ 符号过于朗朗上口，我们常常使用它来表示「平均复杂度」，但从严格意义上看，这种做法并不规范。在本书和其他资料中，若遇到类似“平均时间复杂度 $O(n)$”的表述，请将其直接理解为 $\Theta(n)$ 。
+    可能由于 $O$ 符号过于朗朗上口，我们常常使用它来表示平均时间复杂度。但从严格意义上看，这种做法并不规范。在本书和其他资料中，若遇到类似“平均时间复杂度 $O(n)$”的表述，请将其直接理解为 $\Theta(n)$ 。
diff --git a/docs/chapter_data_structure/basic_data_types.md b/docs/chapter_data_structure/basic_data_types.md
index f3ba3f00..01de6fa1 100644
--- a/docs/chapter_data_structure/basic_data_types.md
+++ b/docs/chapter_data_structure/basic_data_types.md
@@ -16,7 +16,7 @@
 - 整数类型 `byte` 占用 $1$ byte = $8$ bits ，可以表示 $2^{8}$ 个数字。
 - 整数类型 `int` 占用 $4$ bytes = $32$ bits ，可以表示 $2^{32}$ 个数字。
 
-下表列举了各种基本数据类型的占用空间、取值范围和默认值。此表格无需硬背，大致理解即可，需要时可以通过查表来回忆。
+下表列举了各种基本数据类型的占用空间、取值范围和默认值。此表格无须硬背，大致理解即可，需要时可以通过查表来回忆。
 <p align="center"> 表：基本数据类型的占用空间和取值范围 </p>
 
 | 类型   | 符号     | 占用空间         | 最小值                   | 最大值                  | 默认值         |
diff --git a/docs/chapter_data_structure/number_encoding.md b/docs/chapter_data_structure/number_encoding.md
index 4bedb3f3..9cb3e9b7 100644
--- a/docs/chapter_data_structure/number_encoding.md
+++ b/docs/chapter_data_structure/number_encoding.md
@@ -82,7 +82,7 @@ $$
 
 请注意，这并不意味着计算机只能做加法。**通过将加法与一些基本逻辑运算结合，计算机能够实现各种其他的数学运算**。例如，计算减法 $a - b$ 可以转换为计算加法 $a + (-b)$ ；计算乘法和除法可以转换为计算多次加法或减法。
 
-现在我们可以总结出计算机使用补码的原因：基于补码表示，计算机可以用同样的电路和操作来处理正数和负数的加法，不需要设计特殊的硬件电路来处理减法，并且无需特别处理正负零的歧义问题。这大大简化了硬件设计，提高了运算效率。
+现在我们可以总结出计算机使用补码的原因：基于补码表示，计算机可以用同样的电路和操作来处理正数和负数的加法，不需要设计特殊的硬件电路来处理减法，并且无须特别处理正负零的歧义问题。这大大简化了硬件设计，提高了运算效率。
 
 补码的设计非常精妙，因篇幅关系我们就先介绍到这里，建议有兴趣的读者进一步深度了解。
 
diff --git a/docs/chapter_divide_and_conquer/binary_search_recur.md b/docs/chapter_divide_and_conquer/binary_search_recur.md
index 91768155..3bfbd172 100644
--- a/docs/chapter_divide_and_conquer/binary_search_recur.md
+++ b/docs/chapter_divide_and_conquer/binary_search_recur.md
@@ -14,7 +14,7 @@
 
 - **问题可以被分解**：二分查找递归地将原问题（在数组中进行查找）分解为子问题（在数组的一半中进行查找），这是通过比较中间元素和目标元素来实现的。
 - **子问题是独立的**：在二分查找中，每轮只处理一个子问题，它不受另外子问题的影响。
-- **子问题的解无需合并**：二分查找旨在查找一个特定元素，因此不需要将子问题的解进行合并。当子问题得到解决时，原问题也会同时得到解决。
+- **子问题的解无须合并**：二分查找旨在查找一个特定元素，因此不需要将子问题的解进行合并。当子问题得到解决时，原问题也会同时得到解决。
 
 分治能够提升搜索效率，本质上是因为暴力搜索每轮只能排除一个选项，**而分治搜索每轮可以排除一半选项**。
 
diff --git a/docs/chapter_divide_and_conquer/summary.md b/docs/chapter_divide_and_conquer/summary.md
index cfcd90b0..ce22890d 100644
--- a/docs/chapter_divide_and_conquer/summary.md
+++ b/docs/chapter_divide_and_conquer/summary.md
@@ -3,7 +3,7 @@
 - 分治算法是一种常见的算法设计策略，包括分（划分）和治（合并）两个阶段，通常基于递归实现。
 - 判断是否是分治算法问题的依据包括：问题能否被分解、子问题是否独立、子问题是否可以被合并。
 - 归并排序是分治策略的典型应用，其递归地将数组划分为等长的两个子数组，直到只剩一个元素时开始逐层合并，从而完成排序。
-- 引入分治策略往往可以带来算法效率的提升。一方面，分治策略减少了计算操作数量；另一方面，分治后有利于系统的并行优化。
+- 引入分治策略往往可以带来算法效率的提升。一方面，分治策略减少了操作数量；另一方面，分治后有利于系统的并行优化。
 - 分治既可以解决许多算法问题，也广泛应用于数据结构与算法设计中，处处可见其身影。
 - 相较于暴力搜索，自适应搜索效率更高。时间复杂度为 $O(\log n)$ 的搜索算法通常都是基于分治策略实现的。
 - 二分查找是分治思想的另一个典型应用，它不包含将子问题的解进行合并的步骤。我们可以通过递归分治实现二分查找。
diff --git a/docs/chapter_dynamic_programming/dp_problem_features.md b/docs/chapter_dynamic_programming/dp_problem_features.md
index bbfc1d88..60088293 100644
--- a/docs/chapter_dynamic_programming/dp_problem_features.md
+++ b/docs/chapter_dynamic_programming/dp_problem_features.md
@@ -186,7 +186,7 @@ $$
 
 「无后效性」是动态规划能够有效解决问题的重要特性之一，定义为：**给定一个确定的状态，它的未来发展只与当前状态有关，而与当前状态过去所经历过的所有状态无关**。
 
-以爬楼梯问题为例，给定状态 $i$ ，它会发展出状态 $i+1$ 和状态 $i+2$ ，分别对应跳 $1$ 步和跳 $2$ 步。在做出这两种选择时，我们无需考虑状态 $i$ 之前的状态，它们对状态 $i$ 的未来没有影响。
+以爬楼梯问题为例，给定状态 $i$ ，它会发展出状态 $i+1$ 和状态 $i+2$ ，分别对应跳 $1$ 步和跳 $2$ 步。在做出这两种选择时，我们无须考虑状态 $i$ 之前的状态，它们对状态 $i$ 的未来没有影响。
 
 然而，如果我们向爬楼梯问题添加一个约束，情况就不一样了。
 
diff --git a/docs/chapter_dynamic_programming/edit_distance_problem.md b/docs/chapter_dynamic_programming/edit_distance_problem.md
index 885cbf8e..ebedb454 100644
--- a/docs/chapter_dynamic_programming/edit_distance_problem.md
+++ b/docs/chapter_dynamic_programming/edit_distance_problem.md
@@ -53,7 +53,7 @@ $$
 dp[i, j] = \min(dp[i, j-1], dp[i-1, j], dp[i-1, j-1]) + 1
 $$
 
-请注意，**当 $s[i-1]$ 和 $t[j-1]$ 相同时，无需编辑当前字符**，这种情况下的状态转移方程为：
+请注意，**当 $s[i-1]$ 和 $t[j-1]$ 相同时，无须编辑当前字符**，这种情况下的状态转移方程为：
 
 $$
 dp[i, j] = dp[i-1, j-1]
diff --git a/docs/chapter_dynamic_programming/intro_to_dynamic_programming.md b/docs/chapter_dynamic_programming/intro_to_dynamic_programming.md
index 7ff397ff..5a3f646b 100644
--- a/docs/chapter_dynamic_programming/intro_to_dynamic_programming.md
+++ b/docs/chapter_dynamic_programming/intro_to_dynamic_programming.md
@@ -356,7 +356,7 @@ $$
 
 与之相反，**动态规划是一种“从底至顶”的方法**：从最小子问题的解开始，迭代地构建更大子问题的解，直至得到原问题的解。
 
-由于动态规划不包含回溯过程，因此只需使用循环迭代实现，无需使用递归。在以下代码中，我们初始化一个数组 `dp` 来存储子问题的解，它起到了记忆化搜索中数组 `mem` 相同的记录作用。
+由于动态规划不包含回溯过程，因此只需使用循环迭代实现，无须使用递归。在以下代码中，我们初始化一个数组 `dp` 来存储子问题的解，它起到了记忆化搜索中数组 `mem` 相同的记录作用。
 
 === "Java"
 
@@ -442,7 +442,7 @@ $$
 
 ## 状态压缩
 
-细心的你可能发现，**由于 $dp[i]$ 只与 $dp[i-1]$ 和 $dp[i-2]$ 有关，因此我们无需使用一个数组 `dp` 来存储所有子问题的解**，而只需两个变量滚动前进即可。
+细心的你可能发现，**由于 $dp[i]$ 只与 $dp[i-1]$ 和 $dp[i-2]$ 有关，因此我们无须使用一个数组 `dp` 来存储所有子问题的解**，而只需两个变量滚动前进即可。
 
 === "Java"
 
diff --git a/docs/chapter_dynamic_programming/summary.md b/docs/chapter_dynamic_programming/summary.md
index 31d714bf..ee385e5a 100644
--- a/docs/chapter_dynamic_programming/summary.md
+++ b/docs/chapter_dynamic_programming/summary.md
@@ -19,5 +19,5 @@
 **编辑距离问题**
 
 - 编辑距离（Levenshtein 距离）用于衡量两个字符串之间的相似度，其定义为从一个字符串到另一个字符串的最小编辑步数，编辑操作包括添加、删除、替换。
-- 编辑距离问题的状态定义为将 $s$ 的前 $i$ 个字符更改为 $t$ 的前 $j$ 个字符所需的最少编辑步数。当 $s[i] \ne t[j]$ 时，具有三种决策：添加、删除、替换，它们都有相应的剩余子问题。据此便可以找出最优子结构与构建状态转移方程。而当 $s[i] = t[j]$ 时，无需编辑当前字符。
+- 编辑距离问题的状态定义为将 $s$ 的前 $i$ 个字符更改为 $t$ 的前 $j$ 个字符所需的最少编辑步数。当 $s[i] \ne t[j]$ 时，具有三种决策：添加、删除、替换，它们都有相应的剩余子问题。据此便可以找出最优子结构与构建状态转移方程。而当 $s[i] = t[j]$ 时，无须编辑当前字符。
 - 在编辑距离中，状态依赖于其正上方、正左方、左上方的状态，因此状态压缩后正序或倒序遍历都无法正确地进行状态转移。为此，我们利用一个变量暂存左上方状态，从而转化到与完全背包等价的情况，可以在状态压缩后进行正序遍历。
diff --git a/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md b/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md
index e170dd6b..cc160b96 100644
--- a/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md
+++ b/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md
@@ -464,7 +464,7 @@ $$
 dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]]
 $$
 
-当目标金额为 $0$ 时，无需选择任何硬币即可凑出目标金额，因此应将首列所有 $dp[i, 0]$ 都初始化为 $1$ 。当无硬币时，无法凑出任何 $>0$ 的目标金额，因此首行所有 $dp[0, a]$ 都等于 $0$ 。
+当目标金额为 $0$ 时，无须选择任何硬币即可凑出目标金额，因此应将首列所有 $dp[i, 0]$ 都初始化为 $1$ 。当无硬币时，无法凑出任何 $>0$ 的目标金额，因此首行所有 $dp[0, a]$ 都等于 $0$ 。
 
 ### 代码实现
 
diff --git a/docs/chapter_graph/graph_operations.md b/docs/chapter_graph/graph_operations.md
index 4a222dc2..f0de07c8 100644
--- a/docs/chapter_graph/graph_operations.md
+++ b/docs/chapter_graph/graph_operations.md
@@ -129,7 +129,7 @@
 
 - 如果我们选择通过顶点值来区分不同顶点，那么值重复的顶点将无法被区分。
 - 如果类似邻接矩阵那样，使用顶点列表索引来区分不同顶点。那么，假设我们想要删除索引为 $i$ 的顶点，则需要遍历整个邻接表，将其中 $> i$ 的索引全部减 $1$ ，这样操作效率较低。
-- 因此我们考虑引入顶点类 `Vertex` ，使得每个顶点都是唯一的对象，此时删除顶点时就无需改动其余顶点了。
+- 因此我们考虑引入顶点类 `Vertex` ，使得每个顶点都是唯一的对象，此时删除顶点时就无须改动其余顶点了。
 
 === "Java"
 
diff --git a/docs/chapter_greedy/max_product_cutting_problem.md b/docs/chapter_greedy/max_product_cutting_problem.md
index d1ee3674..81bc8a2e 100644
--- a/docs/chapter_greedy/max_product_cutting_problem.md
+++ b/docs/chapter_greedy/max_product_cutting_problem.md
@@ -55,7 +55,7 @@ $$
 
 ### 代码实现
 
-在代码中，我们无需通过循环来切分整数，而可以利用向下整除运算得到 $3$ 的个数 $a$ ，用取模运算得到余数 $b$ ，此时有：
+在代码中，我们无须通过循环来切分整数，而可以利用向下整除运算得到 $3$ 的个数 $a$ ，用取模运算得到余数 $b$ ，此时有：
 
 $$
 n = 3 a + b
diff --git a/docs/chapter_heap/build_heap.md b/docs/chapter_heap/build_heap.md
index a3d4d04b..64f4db6d 100644
--- a/docs/chapter_heap/build_heap.md
+++ b/docs/chapter_heap/build_heap.md
@@ -12,7 +12,7 @@
 
 有趣的是，存在一种更高效的建堆方法，其时间复杂度可以达到 $O(n)$ 。我们先将列表所有元素原封不动添加到堆中，然后倒序遍历该堆，依次对每个节点执行“从顶至底堆化”。
 
-请注意，因为叶节点没有子节点，所以无需堆化。在代码实现中，我们从最后一个节点的父节点开始进行堆化。
+请注意，因为叶节点没有子节点，所以无须堆化。在代码实现中，我们从最后一个节点的父节点开始进行堆化。
 
 === "Java"
 
diff --git a/docs/chapter_heap/heap.md b/docs/chapter_heap/heap.md
index d417ef1f..60923922 100644
--- a/docs/chapter_heap/heap.md
+++ b/docs/chapter_heap/heap.md
@@ -526,7 +526,7 @@
 
 给定元素 `val` ，我们首先将其添加到堆底。添加之后，由于 val 可能大于堆中其他元素，堆的成立条件可能已被破坏。因此，**需要修复从插入节点到根节点的路径上的各个节点**，这个操作被称为「堆化 Heapify」。
 
-考虑从入堆节点开始，**从底至顶执行堆化**。具体来说，我们比较插入节点与其父节点的值，如果插入节点更大，则将它们交换。然后继续执行此操作，从底至顶修复堆中的各个节点，直至越过根节点或遇到无需交换的节点时结束。
+考虑从入堆节点开始，**从底至顶执行堆化**。具体来说，我们比较插入节点与其父节点的值，如果插入节点更大，则将它们交换。然后继续执行此操作，从底至顶修复堆中的各个节点，直至越过根节点或遇到无须交换的节点时结束。
 
 === "<1>"
     ![元素入堆步骤](heap.assets/heap_push_step1.png)
@@ -661,7 +661,7 @@
 2. 交换完成后，将堆底从列表中删除（注意，由于已经交换，实际上删除的是原来的堆顶元素）。
 3. 从根节点开始，**从顶至底执行堆化**。
 
-顾名思义，**从顶至底堆化的操作方向与从底至顶堆化相反**，我们将根节点的值与其两个子节点的值进行比较，将最大的子节点与根节点交换；然后循环执行此操作，直到越过叶节点或遇到无需交换的节点时结束。
+顾名思义，**从顶至底堆化的操作方向与从底至顶堆化相反**，我们将根节点的值与其两个子节点的值进行比较，将最大的子节点与根节点交换；然后循环执行此操作，直到越过叶节点或遇到无须交换的节点时结束。
 
 === "<1>"
     ![堆顶元素出堆步骤](heap.assets/heap_pop_step1.png)
diff --git a/docs/chapter_introduction/algorithms_are_everywhere.md b/docs/chapter_introduction/algorithms_are_everywhere.md
index 5f96542c..afc93728 100644
--- a/docs/chapter_introduction/algorithms_are_everywhere.md
+++ b/docs/chapter_introduction/algorithms_are_everywhere.md
@@ -4,11 +4,11 @@
 
 在正式探讨算法之前，有一个有趣的事实值得分享：**你已经在不知不觉中学会了许多算法，并习惯将它们应用到日常生活中了**。下面，我将举几个具体例子来证实这一点。
 
-**例一：查阅字典**。在字典里，每个汉字都对应一个拼音，而字典是按照拼音的英文字母顺序排列的。假设我们需要查找一个拼音首字母为 $r$ 的字，通常会这样操作：
+**例一：查阅字典**。在字典里，每个汉字都对应一个拼音，而字典是按照拼音字母顺序排列的。假设我们需要查找一个拼音首字母为 $r$ 的字，通常会按照下图所示的方式实现。
 
-1. 翻开字典约一半的页数，查看该页首字母是什么，假设首字母为 $m$ 。
-2. 由于在英文字母表中 $r$ 位于 $m$ 之后，所以排除字典前半部分，查找范围缩小到后半部分。
-3. 不断重复步骤 1-2 ，直至找到拼音首字母为 $r$ 的页码为止。
+1. 翻开字典约一半的页数，查看该页的首字母是什么，假设首字母为 $m$ 。
+2. 由于在拼音字母表中 $r$ 位于 $m$ 之后，所以排除字典前半部分，查找范围缩小到后半部分。
+3. 不断重复步骤 `1.` 和 步骤 `2.` ，直至找到拼音首字母为 $r$ 的页码为止。
 
 === "<1>"
     ![查字典步骤](algorithms_are_everywhere.assets/binary_search_dictionary_step_1.png)
@@ -25,9 +25,9 @@
 === "<5>"
     ![binary_search_dictionary_step_5](algorithms_are_everywhere.assets/binary_search_dictionary_step_5.png)
 
-查阅字典这个小学生必备技能，实际上就是著名的「二分查找」。从数据结构的角度，我们可以把字典视为一个已排序的「数组」；从算法的角度，我们可以将上述查字典的一系列操作看作是「二分查找」算法。
+查阅字典这个小学生必备技能，实际上就是著名的二分查找算法。从数据结构的角度，我们可以把字典视为一个已排序的「数组」；从算法的角度，我们可以将上述查字典的一系列操作看作是「二分查找」。
 
-**例二：整理扑克**。我们在打牌时，每局都需要整理扑克牌，使其从小到大排列，实现流程如下：
+**例二：整理扑克**。我们在打牌时，每局都需要整理扑克牌，使其从小到大排列，实现流程如下图所示。
 
 1. 将扑克牌划分为“有序”和“无序”两部分，并假设初始状态下最左 1 张扑克牌已经有序。
 2. 在无序部分抽出一张扑克牌，插入至有序部分的正确位置；完成后最左 2 张扑克已经有序。
@@ -37,9 +37,9 @@
 
 上述整理扑克牌的方法本质上是「插入排序」算法，它在处理小型数据集时非常高效。许多编程语言的排序库函数中都存在插入排序的身影。
 
-**例三：货币找零**。假设我们在超市购买了 $69$ 元的商品，给收银员付了 $100$ 元，则收银员需要给我们找 $31$ 元。他会很自然地完成以下思考：
+**例三：货币找零**。假设我们在超市购买了 $69$ 元的商品，给收银员付了 $100$ 元，则收银员需要找我们 $31$ 元。他会很自然地完成如下图所示的思考。
 
-1. 可选项是比 $31$ 元面值更小的货币，包括 $1$ , $5$ , $10$ , $20$ 元。
+1. 可选项是比 $31$ 元面值更小的货币，包括 $1$ 元、$5$ 元、$10$ 元、$20$ 元。
 2. 从可选项中拿出最大的 $20$ 元，剩余 $31 - 20 = 11$ 元。
 3. 从剩余可选项中拿出最大的 $10$ 元，剩余 $11 - 10 = 1$ 元。
 4. 从剩余可选项中拿出最大的 $1$ 元，剩余 $1 - 1 = 0$ 元。
@@ -53,4 +53,4 @@
 
 !!! tip
 
-    阅读至此，如果你对数据结构、算法、数组和二分查找等概念仍感到一知半解，那么太好了！因为这正是本书存在的意义。接下来，这本书将引导你一步步深入数据结构与算法的知识殿堂。
+    阅读至此，如果你对数据结构、算法、数组和二分查找等概念仍感到一知半解，请继续往下阅读，因为这正是本书存在的意义。接下来，这本书将引导你一步步深入数据结构与算法的知识殿堂。
diff --git a/docs/chapter_introduction/summary.md b/docs/chapter_introduction/summary.md
index cb24607e..fac5e075 100644
--- a/docs/chapter_introduction/summary.md
+++ b/docs/chapter_introduction/summary.md
@@ -1,9 +1,9 @@
 # 小结
 
 - 算法在日常生活中无处不在，并不是遥不可及的高深知识。实际上，我们已经在不知不觉中学会了许多算法，用以解决生活中的大小问题。
-- 查阅字典的原理与二分查找算法相一致。二分查找体现了分而治之的重要算法思想。
-- 整理扑克的过程与插入排序算法非常类似。插入排序适合排序小型数据集。
-- 货币找零的步骤本质上是贪心算法，每一步都采取当前看来的最好选择。
+- 查阅字典的原理与二分查找算法相一致。二分查找算法体现了分而治之的重要算法思想。
+- 整理扑克的过程与插入排序算法非常类似。插入排序算法适合排序小型数据集。
+- 货币找零的步骤本质上是贪心算法，每一步都采取当前看来的最好的选择。
 - 算法是在有限时间内解决特定问题的一组指令或操作步骤，而数据结构是计算机中组织和存储数据的方式。
 - 数据结构与算法紧密相连。数据结构是算法的基石，而算法则是发挥数据结构作用的舞台。
-- 乐高积木对应于数据，积木形状和连接方式代表数据结构，拼装积木的步骤则对应算法。
+- 我们可以将数据结构与算法类比为拼装积木，积木代表数据，积木的形状和连接方式代表数据结构，拼装积木的步骤则对应算法。
diff --git a/docs/chapter_introduction/what_is_dsa.md b/docs/chapter_introduction/what_is_dsa.md
index bf98a38c..4b7e3ec1 100644
--- a/docs/chapter_introduction/what_is_dsa.md
+++ b/docs/chapter_introduction/what_is_dsa.md
@@ -2,7 +2,7 @@
 
 ## 算法定义
 
-「算法 Algorithm」是在有限时间内解决特定问题的一组指令或操作步骤。它具有以下特性：
+「算法 algorithm」是在有限时间内解决特定问题的一组指令或操作步骤，它具有以下特性：
 
 - 问题是明确的，包含清晰的输入和输出定义。
 - 具有可行性，能够在有限步骤、时间和内存空间下完成。
@@ -10,7 +10,7 @@
 
 ## 数据结构定义
 
-「数据结构 Data Structure」是计算机中组织和存储数据的方式。它的设计目标包括：
+「数据结构 data structure」是计算机中组织和存储数据的方式，它的设计目标如下：
 
 - 空间占用尽量减少，节省计算机内存。
 - 数据操作尽可能快速，涵盖数据访问、添加、删除、更新等。
@@ -23,22 +23,23 @@
 
 ## 数据结构与算法的关系
 
-数据结构与算法高度相关、紧密结合，具体表现在：
+数据结构与算法高度相关、紧密结合，具体表现在以下几个方面。
 
 - 数据结构是算法的基石。数据结构为算法提供了结构化存储的数据，以及用于操作数据的方法。
-- 算法是数据结构发挥的舞台。数据结构本身仅存储数据信息，通过结合算法才能解决特定问题。
-- 特定算法通常有对应最优的数据结构。算法通常可以基于不同的数据结构进行实现，但最终执行效率可能相差很大。
+- 算法是数据结构发挥作用的舞台。数据结构本身仅存储数据信息，通过结合算法才能解决特定问题。
+- 特定算法通常会有对应最优的数据结构。算法通常可以基于不同的数据结构进行实现，但最终执行效率可能相差很大。
 
 ![数据结构与算法的关系](what_is_dsa.assets/relationship_between_data_structure_and_algorithm.png)
 
-数据结构与算法犹如拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。
+数据结构与算法犹如上图所示的拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。
 
 ![拼装积木](what_is_dsa.assets/assembling_blocks.jpg)
 
 两者的详细对应关系如下表所示。
+
 <p align="center"> 表：将数据结构与算法类比为积木 </p>
 
-| 数据结构与算法 | 积木                                |
+| 数据结构与算法 | 拼装积木                                |
 | -------------- | ---------------------------------------- |
 | 输入数据       | 未拼装的积木                             |
 | 数据结构       | 积木组织形式，包括形状、大小、连接方式等 |
diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md
index 11c8d879..3487acd8 100755
--- a/docs/chapter_searching/binary_search.md
+++ b/docs/chapter_searching/binary_search.md
@@ -208,7 +208,7 @@
 二分查找在时间和空间方面都有较好的性能：
 
 - 二分查找的时间效率高。在大数据量下，对数阶的时间复杂度具有显著优势。例如，当数据大小 $n = 2^{20}$ 时，线性查找需要 $2^{20} = 1048576$ 轮循环，而二分查找仅需 $\log_2 2^{20} = 20$ 轮循环。
-- 二分查找无需额外空间。相较于需要借助额外空间的搜索算法（例如哈希查找），二分查找更加节省空间。
+- 二分查找无须额外空间。相较于需要借助额外空间的搜索算法（例如哈希查找），二分查找更加节省空间。
 
 然而，二分查找并非适用于所有情况，原因如下：
 
diff --git a/docs/chapter_searching/binary_search_edge.md b/docs/chapter_searching/binary_search_edge.md
index 0f550f9a..71cb2cf6 100644
--- a/docs/chapter_searching/binary_search_edge.md
+++ b/docs/chapter_searching/binary_search_edge.md
@@ -188,5 +188,5 @@
 
 代码在此省略，值得注意的有：
 
-- 给定数组不包含小数，这意味着我们无需关心如何处理相等的情况。
+- 给定数组不包含小数，这意味着我们无须关心如何处理相等的情况。
 - 因为该方法引入了小数，所以需要将函数中的变量 `target` 改为浮点数类型。
diff --git a/docs/chapter_searching/searching_algorithm_revisited.md b/docs/chapter_searching/searching_algorithm_revisited.md
index 6c563a32..8f6cdc6f 100644
--- a/docs/chapter_searching/searching_algorithm_revisited.md
+++ b/docs/chapter_searching/searching_algorithm_revisited.md
@@ -16,7 +16,7 @@
 - 「线性搜索」适用于数组和链表等线性数据结构。它从数据结构的一端开始，逐个访问元素，直到找到目标元素或到达另一端仍没有找到目标元素为止。
 - 「广度优先搜索」和「深度优先搜索」是图和树的两种遍历策略。广度优先搜索从初始节点开始逐层搜索，由近及远地访问各个节点。深度优先搜索是从初始节点开始，沿着一条路径走到头为止，再回溯并尝试其他路径，直到遍历完整个数据结构。
 
-暴力搜索的优点是简单且通用性好，**无需对数据做预处理和借助额外的数据结构**。
+暴力搜索的优点是简单且通用性好，**无须对数据做预处理和借助额外的数据结构**。
 
 然而，**此类算法的时间复杂度为 $O(n)$** ，其中 $n$ 为元素数量，因此在数据量较大的情况下性能较差。
 
@@ -58,7 +58,7 @@
 
 **线性搜索**
 
-- 通用性较好，无需任何数据预处理操作。假如我们仅需查询一次数据，那么其他三种方法的数据预处理的时间比线性搜索的时间还要更长。
+- 通用性较好，无须任何数据预处理操作。假如我们仅需查询一次数据，那么其他三种方法的数据预处理的时间比线性搜索的时间还要更长。
 - 适用于体量较小的数据，此情况下时间复杂度对效率影响较小。
 - 适用于数据更新频率较高的场景，因为该方法不需要对数据进行任何额外维护。
 
diff --git a/docs/chapter_searching/summary.md b/docs/chapter_searching/summary.md
index 31798c02..f6ca5e85 100644
--- a/docs/chapter_searching/summary.md
+++ b/docs/chapter_searching/summary.md
@@ -1,8 +1,8 @@
 # 小结
 
 - 二分查找依赖于数据的有序性，通过循环逐步缩减一半搜索区间来实现查找。它要求输入数据有序，且仅适用于数组或基于数组实现的数据结构。
-- 暴力搜索通过遍历数据结构来定位数据。线性搜索适用于数组和链表，广度优先搜索和深度优先搜索适用于图和树。此类算法通用性好，无需对数据预处理，但时间复杂度 $O(n)$ 较高。
+- 暴力搜索通过遍历数据结构来定位数据。线性搜索适用于数组和链表，广度优先搜索和深度优先搜索适用于图和树。此类算法通用性好，无须对数据预处理，但时间复杂度 $O(n)$ 较高。
 - 哈希查找、树查找和二分查找属于高效搜索方法，可在特定数据结构中快速定位目标元素。此类算法效率高，时间复杂度可达 $O(\log n)$ 甚至 $O(1)$ ，但通常需要借助额外数据结构。
 - 实际中，我们需要对数据体量、搜索性能要求、数据查询和更新频率等因素进行具体分析，从而选择合适的搜索方法。
-- 线性搜索适用于小型或频繁更新的数据；二分查找适用于大型、排序的数据；哈希查找适合对查询效率要求较高且无需范围查询的数据；树查找适用于需要维护顺序和支持范围查询的大型动态数据。
+- 线性搜索适用于小型或频繁更新的数据；二分查找适用于大型、排序的数据；哈希查找适合对查询效率要求较高且无须范围查询的数据；树查找适用于需要维护顺序和支持范围查询的大型动态数据。
 - 用哈希查找替换线性查找是一种常用的优化运行时间的策略，可将时间复杂度从 $O(n)$ 降低至 $O(1)$ 。 
diff --git a/docs/chapter_sorting/bubble_sort.md b/docs/chapter_sorting/bubble_sort.md
index ac8f15fe..b987155b 100755
--- a/docs/chapter_sorting/bubble_sort.md
+++ b/docs/chapter_sorting/bubble_sort.md
@@ -32,7 +32,7 @@
 1. 首先，对 $n$ 个元素执行“冒泡”，**将数组的最大元素交换至正确位置**，
 2. 接下来，对剩余 $n - 1$ 个元素执行“冒泡”，**将第二大元素交换至正确位置**。
 3. 以此类推，经过 $n - 1$ 轮“冒泡”后，**前 $n - 1$ 大的元素都被交换至正确位置**。
-4. 仅剩的一个元素必定是最小元素，无需排序，因此数组排序完成。
+4. 仅剩的一个元素必定是最小元素，无须排序，因此数组排序完成。
 
 ![冒泡排序流程](bubble_sort.assets/bubble_sort_overview.png)
 
diff --git a/docs/chapter_sorting/insertion_sort.md b/docs/chapter_sorting/insertion_sort.md
index 90271835..68f7d843 100755
--- a/docs/chapter_sorting/insertion_sort.md
+++ b/docs/chapter_sorting/insertion_sort.md
@@ -101,7 +101,7 @@
 
 插入排序的时间复杂度为 $O(n^2)$ ，而我们即将学习的快速排序的时间复杂度为 $O(n \log n)$ 。尽管插入排序的时间复杂度相比快速排序更高，**但在数据量较小的情况下，插入排序通常更快**。
 
-这个结论与线性查找和二分查找的适用情况的结论类似。快速排序这类 $O(n \log n)$ 的算法属于基于分治的排序算法，往往包含更多单元计算操作。而在数据量较小时，$n^2$ 和 $n \log n$ 的数值比较接近，复杂度不占主导作用；每轮中的单元计算操作数量起到决定性因素。
+这个结论与线性查找和二分查找的适用情况的结论类似。快速排序这类 $O(n \log n)$ 的算法属于基于分治的排序算法，往往包含更多单元计算操作。而在数据量较小时，$n^2$ 和 $n \log n$ 的数值比较接近，复杂度不占主导作用；每轮中的单元操作数量起到决定性因素。
 
 实际上，许多编程语言（例如 Java）的内置排序函数都采用了插入排序，大致思路为：对于长数组，采用基于分治的排序算法，例如快速排序；对于短数组，直接使用插入排序。
 
diff --git a/docs/chapter_sorting/merge_sort.md b/docs/chapter_sorting/merge_sort.md
index 8de55b2b..11859ded 100755
--- a/docs/chapter_sorting/merge_sort.md
+++ b/docs/chapter_sorting/merge_sort.md
@@ -162,7 +162,7 @@
 
 归并排序在排序链表时具有显著优势，空间复杂度可以优化至 $O(1)$ ，原因如下：
 
-- 由于链表仅需改变指针就可实现节点的增删操作，因此合并阶段（将两个短有序链表合并为一个长有序链表）无需创建辅助链表。
+- 由于链表仅需改变指针就可实现节点的增删操作，因此合并阶段（将两个短有序链表合并为一个长有序链表）无须创建辅助链表。
 - 通过使用“迭代划分”替代“递归划分”，可省去递归使用的栈帧空间。
 
 具体实现细节比较复杂，有兴趣的同学可以查阅相关资料进行学习。
diff --git a/docs/chapter_sorting/selection_sort.md b/docs/chapter_sorting/selection_sort.md
index 9ddd30b1..1207c3b4 100644
--- a/docs/chapter_sorting/selection_sort.md
+++ b/docs/chapter_sorting/selection_sort.md
@@ -8,7 +8,7 @@
 2. 选取区间 $[0, n-1]$ 中的最小元素，将其与索引 $0$ 处元素交换。完成后，数组前 1 个元素已排序。
 3. 选取区间 $[1, n-1]$ 中的最小元素，将其与索引 $1$ 处元素交换。完成后，数组前 2 个元素已排序。
 4. 以此类推。经过 $n - 1$ 轮选择与交换后，数组前 $n - 1$ 个元素已排序。
-5. 仅剩的一个元素必定是最大元素，无需排序，因此数组排序完成。
+5. 仅剩的一个元素必定是最大元素，无须排序，因此数组排序完成。
 
 === "<1>"
     ![选择排序步骤](selection_sort.assets/selection_sort_step1.png)
diff --git a/docs/chapter_sorting/sorting_algorithm.md b/docs/chapter_sorting/sorting_algorithm.md
index b498aee2..f8c201a4 100644
--- a/docs/chapter_sorting/sorting_algorithm.md
+++ b/docs/chapter_sorting/sorting_algorithm.md
@@ -10,7 +10,7 @@
 
 **运行效率**：我们期望排序算法的时间复杂度尽量低，且总体操作数量较少（即时间复杂度中的常数项降低）。对于大数据量情况，运行效率显得尤为重要。
 
-**就地性**：顾名思义，「原地排序」通过在原数组上直接操作实现排序，无需借助额外的辅助数组，从而节省内存。通常情况下，原地排序的数据搬运操作较少，运行速度也更快。
+**就地性**：顾名思义，「原地排序」通过在原数组上直接操作实现排序，无须借助额外的辅助数组，从而节省内存。通常情况下，原地排序的数据搬运操作较少，运行速度也更快。
 
 **稳定性**：「稳定排序」在完成排序后，相等元素在数组中的相对顺序不发生改变。稳定排序是优良特性，也是多级排序场景的必要条件。
 
diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md
index 8d461797..1e95e14c 100755
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@@ -388,7 +388,7 @@
 === "pop()"
     ![array_stack_pop](stack.assets/array_stack_pop.png)
 
-由于入栈的元素可能会源源不断地增加，因此我们可以使用动态数组，这样就无需自行处理数组扩容问题。以下为示例代码。
+由于入栈的元素可能会源源不断地增加，因此我们可以使用动态数组，这样就无须自行处理数组扩容问题。以下为示例代码。
 
 === "Java"
 
diff --git a/docs/chapter_tree/binary_search_tree.md b/docs/chapter_tree/binary_search_tree.md
index 9d07784e..38e814fe 100755
--- a/docs/chapter_tree/binary_search_tree.md
+++ b/docs/chapter_tree/binary_search_tree.md
@@ -301,7 +301,7 @@
 
 我们知道，二叉树的中序遍历遵循“左 $\rightarrow$ 根 $\rightarrow$ 右”的遍历顺序，而二叉搜索树满足“左子节点 $<$ 根节点 $<$ 右子节点”的大小关系。因此，在二叉搜索树中进行中序遍历时，总是会优先遍历下一个最小节点，从而得出一个重要性质：**二叉搜索树的中序遍历序列是升序的**。
 
-利用中序遍历升序的性质，我们在二叉搜索树中获取有序数据仅需 $O(n)$ 时间，无需额外排序，非常高效。
+利用中序遍历升序的性质，我们在二叉搜索树中获取有序数据仅需 $O(n)$ 时间，无须额外排序，非常高效。
 
 ![二叉搜索树的中序遍历序列](binary_search_tree.assets/bst_inorder_traversal.png)