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

@@ -11,7 +11,7 @@ func bucketSort(nums: inout [Double]) {
     var buckets = (0 ..< k).map { _ in [Double]() }
     // 1. 将数组元素分配到各个桶中
     for num in nums {
-        // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
+        // 输入数据范围为 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
         let i = Int(num * Double(k))
         // 将 num 添加进桶 i
         buckets[i].append(num)

codes/swift/chapter_sorting/heap_sort.swift

@@ -37,7 +37,7 @@ func heapSort(nums: inout [Int]) {
     }
     // 从堆中提取最大元素，循环 n-1 轮
     for i in stride(from: nums.count - 1, to: 0, by: -1) {
-        // 交换根节点与最右叶节点（即交换首元素与尾元素）
+        // 交换根节点与最右叶节点（交换首元素与尾元素）
         nums.swapAt(0, i)
         // 以根节点为起点，从顶至底进行堆化
         siftDown(nums: &nums, n: i, i: 0)

codes/swift/chapter_sorting/quick_sort.swift

@@ -14,7 +14,7 @@ func swap(nums: inout [Int], i: Int, j: Int) {
 /* 快速排序类 */
 /* 哨兵划分 */
 func partition(nums: inout [Int], left: Int, right: Int) -> Int {
-    // 以 nums[left] 作为基准数
+    // 以 nums[left] 为基准数
     var i = left
     var j = right
     while i < j {
@@ -87,7 +87,7 @@ func quickSortTailCall(nums: inout [Int], left: Int, right: Int) {
     while left < right {
         // 哨兵划分操作
         let pivot = partition(nums: &nums, left: left, right: right)
-        // 对两个子数组中较短的那个执行快排
+        // 对两个子数组中较短的那个执行快速排序
         if (pivot - left) < (right - pivot) {
             quickSortTailCall(nums: &nums, left: left, right: pivot - 1) // 递归排序左子数组
             left = pivot + 1 // 剩余未排序区间为 [pivot + 1, right]

codes/swift/chapter_sorting/radix_sort.swift

@@ -12,7 +12,7 @@ func digit(num: Int, exp: Int) -> Int {
 
 /* 计数排序（根据 nums 第 k 位排序） */
 func countingSortDigit(nums: inout [Int], exp: Int) {
-    // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
+    // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶数组
     var counter = Array(repeating: 0, count: 10)
     let n = nums.count
     // 统计 0~9 各数字的出现次数