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/csharp/chapter_sorting/bucket_sort.cs

@@ -17,7 +17,7 @@ public class bucket_sort {
         }
         // 1. 将数组元素分配到各个桶中
         foreach (float num in nums) {
-            // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+            // 输入数据范围为 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
             int i = (int)(num * k);
             // 将 num 添加进桶 i
             buckets[i].Add(num);

codes/csharp/chapter_sorting/heap_sort.cs

@@ -36,7 +36,7 @@ public class heap_sort {
         }
         // 从堆中提取最大元素，循环 n-1 轮
         for (int i = nums.Length - 1; i > 0; i--) {
-            // 交换根节点与最右叶节点（即交换首元素与尾元素）
+            // 交换根节点与最右叶节点（交换首元素与尾元素）
             (nums[i], nums[0]) = (nums[0], nums[i]);
             // 以根节点为起点，从顶至底进行堆化
             SiftDown(nums, i, 0);

codes/csharp/chapter_sorting/quick_sort.cs

@@ -14,7 +14,7 @@ class quickSort {
 
     /* 哨兵划分 */
     static int Partition(int[] nums, int left, int right) {
-        // 以 nums[left] 作为基准数
+        // 以 nums[left] 为基准数
         int i = left, j = right;
         while (i < j) {
             while (i < j && nums[j] >= nums[left])
@@ -65,7 +65,7 @@ class QuickSortMedian {
         int med = MedianThree(nums, left, (left + right) / 2, right);
         // 将中位数交换至数组最左端
         Swap(nums, left, med);
-        // 以 nums[left] 作为基准数
+        // 以 nums[left] 为基准数
         int i = left, j = right;
         while (i < j) {
             while (i < j && nums[j] >= nums[left])
@@ -100,7 +100,7 @@ class QuickSortTailCall {
 
     /* 哨兵划分 */
     static int Partition(int[] nums, int left, int right) {
-        // 以 nums[left] 作为基准数
+        // 以 nums[left] 为基准数
         int i = left, j = right;
         while (i < j) {
             while (i < j && nums[j] >= nums[left])
@@ -119,7 +119,7 @@ class QuickSortTailCall {
         while (left < right) {
             // 哨兵划分操作
             int pivot = Partition(nums, left, right);
-            // 对两个子数组中较短的那个执行快排
+            // 对两个子数组中较短的那个执行快速排序
             if (pivot - left < right - pivot) {
                 QuickSort(nums, left, pivot - 1);  // 递归排序左子数组
                 left = pivot + 1;  // 剩余未排序区间为 [pivot + 1, right]

codes/csharp/chapter_sorting/radix_sort.cs

@@ -15,7 +15,7 @@ public class radix_sort {
 
     /* 计数排序（根据 nums 第 k 位排序） */
     void CountingSortDigit(int[] nums, int exp) {
-        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+        // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶数组
         int[] counter = new int[10];
         int n = nums.Length;
         // 统计 0~9 各数字的出现次数