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

@@ -34,7 +34,7 @@ void bucketSort(float nums[], int size) {
 
     // 1. 将数组元素分配到各个桶中
     for (int i = 0; i < size; i++) {
-        // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+        // 输入数据范围为 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
         int bucket_idx = nums[i] * k;
         int j = 0;
         // 如果桶中有数据且数据小于当前值 nums[i], 要将其放到当前桶的后面，相当于 cpp 中的 push_back

codes/c/chapter_sorting/heap_sort.c

@@ -38,7 +38,7 @@ void heapSort(int nums[], int n) {
     }
     // 从堆中提取最大元素，循环 n-1 轮
     for (int i = n - 1; i > 0; --i) {
-        // 交换根节点与最右叶节点（即交换首元素与尾元素）
+        // 交换根节点与最右叶节点（交换首元素与尾元素）
         int tmp = nums[0];
         nums[0] = nums[i];
         nums[i] = tmp;

codes/c/chapter_sorting/quick_sort.c

@@ -16,7 +16,7 @@ void swap(int nums[], int i, int j) {
 /* 快速排序类 */
 // 快速排序类-哨兵划分
 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]) {
@@ -68,7 +68,7 @@ int partitionMedian(int nums[], int left, int right) {
     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 @@ void quickSortTailCall(int nums[], int left, int right) {
     while (left < right) {
         // 哨兵划分操作
         int pivot = partition(nums, left, right);
-        // 对两个子数组中较短的那个执行快排
+        // 对两个子数组中较短的那个执行快速排序
         if (pivot - left < right - pivot) {
             quickSortTailCall(nums, left, pivot - 1); // 递归排序左子数组
             left = pivot + 1;                         // 剩余未排序区间为 [pivot + 1, right]

codes/c/chapter_sorting/radix_sort.c

@@ -14,7 +14,7 @@ int digit(int num, int exp) {
 
 /* 计数排序（根据 nums 第 k 位排序） */
 void countingSortDigit(int nums[], int size, int exp) {
-    // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+    // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶数组
     int *counter = (int *)malloc((sizeof(int) * 10));
     // 统计 0~9 各数字的出现次数
     for (int i = 0; i < size; i++) {