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

@@ -12,7 +12,7 @@ def bucket_sort(nums: list[float]):
     buckets = [[] for _ in range(k)]
     # 1. 将数组元素分配到各个桶中
     for num in nums:
-        # 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+        # 输入数据范围为 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
         i = int(num * k)
         # 将 num 添加进桶 i
         buckets[i].append(num)

codes/python/chapter_sorting/heap_sort.py

@@ -32,7 +32,7 @@ def heap_sort(nums: list[int]):
         sift_down(nums, len(nums), i)
     # 从堆中提取最大元素，循环 n-1 轮
     for i in range(len(nums) - 1, 0, -1):
-        # 交换根节点与最右叶节点（即交换首元素与尾元素）
+        # 交换根节点与最右叶节点（交换首元素与尾元素）
         nums[0], nums[i] = nums[i], nums[0]
         # 以根节点为起点，从顶至底进行堆化
         sift_down(nums, i, 0)

codes/python/chapter_sorting/quick_sort.py

@@ -10,7 +10,7 @@ class QuickSort:
 
     def partition(self, nums: list[int], left: int, right: int) -> int:
         """哨兵划分"""
-        # 以 nums[left] 作为基准数
+        # 以 nums[left] 为基准数
         i, j = left, right
         while i < j:
             while i < j and nums[j] >= nums[left]:
@@ -50,11 +50,11 @@ class QuickSortMedian:
 
     def partition(self, nums: list[int], left: int, right: int) -> int:
         """哨兵划分（三数取中值）"""
-        # 以 nums[left] 作为基准数
+        # 以 nums[left] 为基准数
         med = self.median_three(nums, left, (left + right) // 2, right)
         # 将中位数交换至数组最左端
         nums[left], nums[med] = nums[med], nums[left]
-        # 以 nums[left] 作为基准数
+        # 以 nums[left] 为基准数
         i, j = left, right
         while i < j:
             while i < j and nums[j] >= nums[left]:
@@ -84,7 +84,7 @@ class QuickSortTailCall:
 
     def partition(self, nums: list[int], left: int, right: int) -> int:
         """哨兵划分"""
-        # 以 nums[left] 作为基准数
+        # 以 nums[left] 为基准数
         i, j = left, right
         while i < j:
             while i < j and nums[j] >= nums[left]:
@@ -103,7 +103,7 @@ class QuickSortTailCall:
         while left < right:
             # 哨兵划分操作
             pivot = self.partition(nums, left, right)
-            # 对两个子数组中较短的那个执行快排
+            # 对两个子数组中较短的那个执行快速排序
             if pivot - left < right - pivot:
                 self.quick_sort(nums, left, pivot - 1)  # 递归排序左子数组
                 left = pivot + 1  # 剩余未排序区间为 [pivot + 1, right]

codes/python/chapter_sorting/radix_sort.py

@@ -13,7 +13,7 @@ def digit(num: int, exp: int) -> int:
 
 def counting_sort_digit(nums: list[int], exp: int):
     """计数排序（根据 nums 第 k 位排序）"""
-    # 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+    # 十进制的位范围为 0~9 ，因此需要长度为 10 的桶数组
     counter = [0] * 10
     n = len(nums)
     # 统计 0~9 各数字的出现次数