feat: Revised the book (#978)

* Sync recent changes to the revised Word.

* Revised the preface chapter

* Revised the introduction chapter

* Revised the computation complexity chapter

* Revised the chapter data structure

* Revised the chapter array and linked list

* Revised the chapter stack and queue

* Revised the chapter hashing

* Revised the chapter tree

* Revised the chapter heap

* Revised the chapter graph

* Revised the chapter searching

* Reivised the sorting chapter

* Revised the divide and conquer chapter

* Revised the chapter backtacking

* Revised the DP chapter

* Revised the greedy chapter

* Revised the appendix chapter

* Revised the preface chapter doubly

* Revised the figures

codes/rust/chapter_sorting/bucket_sort.rs

@@ -13,7 +13,7 @@ fn bucket_sort(nums: &mut [f64]) {
     let mut buckets = vec![vec![]; k];
     // 1. 将数组元素分配到各个桶中
     for &mut num in &mut *nums {
-        // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+        // 输入数据范围为 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
         let i = (num * k as f64) as usize;
         // 将 num 添加进桶 i
         buckets[i].push(num);

codes/rust/chapter_sorting/heap_sort.rs

@@ -40,7 +40,7 @@ fn heap_sort(nums: &mut [i32]) {
     }
     // 从堆中提取最大元素，循环 n-1 轮
     for i in (1..=nums.len() - 1).rev() {
-        // 交换根节点与最右叶节点（即交换首元素与尾元素）
+        // 交换根节点与最右叶节点（交换首元素与尾元素）
         let tmp = nums[0];
         nums[0] = nums[i];
         nums[i] = tmp;

codes/rust/chapter_sorting/quick_sort.rs

@@ -11,7 +11,7 @@ struct QuickSort;
 impl QuickSort {
     /* 哨兵划分 */
     fn partition(nums: &mut [i32], left: usize, right: usize) -> usize {
-        // 以 nums[left] 作为基准数
+        // 以 nums[left] 为基准数
         let (mut i, mut j) = (left, right);
         while i < j {
             while i < j && nums[j] >= nums[left] {
@@ -62,7 +62,7 @@ impl QuickSortMedian {
         let med = Self::median_three(nums, left, (left + right) / 2, right);
         // 将中位数交换至数组最左端
         nums.swap(left, med);
-        // 以 nums[left] 作为基准数
+        // 以 nums[left] 为基准数
         let (mut i, mut j) = (left, right);
         while i < j {
             while i < j && nums[j] >= nums[left] {
@@ -97,7 +97,7 @@ struct QuickSortTailCall;
 impl QuickSortTailCall {
     /* 哨兵划分 */
     fn partition(nums: &mut [i32], left: usize, right: usize) -> usize {
-        // 以 nums[left] 作为基准数
+        // 以 nums[left] 为基准数
         let (mut i, mut j) = (left, right);
         while i < j {
             while i < j && nums[j] >= nums[left] {
@@ -118,7 +118,7 @@ impl QuickSortTailCall {
         while left < right {
             // 哨兵划分操作
             let pivot = Self::partition(nums, left as usize, right as usize) as i32;
-            // 对两个子数组中较短的那个执行快排
+            // 对两个子数组中较短的那个执行快速排序
             if  pivot - left < right - pivot {
                 Self::quick_sort(left, pivot - 1, nums);  // 递归排序左子数组
                 left = pivot + 1;  // 剩余未排序区间为 [pivot + 1, right]

codes/rust/chapter_sorting/radix_sort.rs

@@ -14,7 +14,7 @@ fn digit(num: i32, exp: i32) -> usize {
 
 /* 计数排序（根据 nums 第 k 位排序） */
 fn counting_sort_digit(nums: &mut [i32], exp: i32) {
-    // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+    // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶数组
     let mut counter = [0; 10];
     let n = nums.len();
     // 统计 0~9 各数字的出现次数