Update the book based on the revised second edition (#1014)

* Revised the book

* Update the book with the second revised edition

* Revise base on the manuscript of the first edition

codes/cpp/chapter_array_and_linkedlist/my_list.cpp

@@ -37,7 +37,7 @@ class MyList {
 
     /* 访问元素 */
     int get(int index) {
-        // 索引如果越界则抛出异常，下同
+        // 索引如果越界，则抛出异常，下同
         if (index < 0 || index >= size())
             throw out_of_range("索引越界");
         return arr[index];
@@ -87,7 +87,7 @@ class MyList {
         }
         // 更新元素数量
         arrSize--;
-        // 返回被删除元素
+        // 返回被删除的元素
         return num;
     }
 

codes/cpp/chapter_backtracking/n_queens.cpp

@@ -16,10 +16,10 @@ void backtrack(int row, int n, vector<vector<string>> &state, vector<vector<vect
     }
     // 遍历所有列
     for (int col = 0; col < n; col++) {
-        // 计算该格子对应的主对角线和副对角线
+        // 计算该格子对应的主对角线和次对角线
         int diag1 = row - col + n - 1;
         int diag2 = row + col;
-        // 剪枝：不允许该格子所在列、主对角线、副对角线上存在皇后
+        // 剪枝：不允许该格子所在列、主对角线、次对角线上存在皇后
         if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
             // 尝试：将皇后放置在该格子
             state[row][col] = "Q";
@@ -39,7 +39,7 @@ vector<vector<vector<string>>> nQueens(int n) {
     vector<vector<string>> state(n, vector<string>(n, "#"));
     vector<bool> cols(n, false);           // 记录列是否有皇后
     vector<bool> diags1(2 * n - 1, false); // 记录主对角线上是否有皇后
-    vector<bool> diags2(2 * n - 1, false); // 记录副对角线上是否有皇后
+    vector<bool> diags2(2 * n - 1, false); // 记录次对角线上是否有皇后
     vector<vector<vector<string>>> res;
 
     backtrack(0, n, state, res, cols, diags1, diags2);

codes/cpp/chapter_graph/graph_bfs.cpp

@@ -7,7 +7,7 @@
 #include "../utils/common.hpp"
 #include "./graph_adjacency_list.cpp"
 
-/* 广度优先遍历 BFS */
+/* 广度优先遍历 */
 // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
 vector<Vertex *> graphBFS(GraphAdjList &graph, Vertex *startVet) {
     // 顶点遍历序列
@@ -45,7 +45,7 @@ int main() {
     cout << "\n初始化后，图为\\n";
     graph.print();
 
-    /* 广度优先遍历 BFS */
+    /* 广度优先遍历 */
     vector<Vertex *> res = graphBFS(graph, v[0]);
     cout << "\n广度优先遍历（BFS）顶点序列为" << endl;
     printVector(vetsToVals(res));

codes/cpp/chapter_graph/graph_dfs.cpp

@@ -7,7 +7,7 @@
 #include "../utils/common.hpp"
 #include "./graph_adjacency_list.cpp"
 
-/* 深度优先遍历 DFS 辅助函数 */
+/* 深度优先遍历辅助函数 */
 void dfs(GraphAdjList &graph, unordered_set<Vertex *> &visited, vector<Vertex *> &res, Vertex *vet) {
     res.push_back(vet);   // 记录访问顶点
     visited.emplace(vet); // 标记该顶点已被访问
@@ -20,7 +20,7 @@ void dfs(GraphAdjList &graph, unordered_set<Vertex *> &visited, vector<Vertex *>
     }
 }
 
-/* 深度优先遍历 DFS */
+/* 深度优先遍历 */
 // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
 vector<Vertex *> graphDFS(GraphAdjList &graph, Vertex *startVet) {
     // 顶点遍历序列
@@ -41,7 +41,7 @@ int main() {
     cout << "\n初始化后，图为" << endl;
     graph.print();
 
-    /* 深度优先遍历 DFS */
+    /* 深度优先遍历 */
     vector<Vertex *> res = graphDFS(graph, v[0]);
     cout << "\n深度优先遍历（DFS）顶点序列为" << endl;
     printVector(vetsToVals(res));

codes/cpp/chapter_greedy/max_capacity.cpp

@@ -8,7 +8,7 @@
 
 /* 最大容量：贪心 */
 int maxCapacity(vector<int> &ht) {
-    // 初始化 i, j 分列数组两端
+    // 初始化 i, j，使其分列数组两端
     int i = 0, j = ht.size() - 1;
     // 初始最大容量为 0
     int res = 0;

codes/cpp/chapter_hashing/array_hash_map_test.cpp

@@ -22,7 +22,7 @@ int main() {
     map.print();
 
     /* 查询操作 */
-    // 向哈希表输入键 key ，得到值 value
+    // 向哈希表中输入键 key ，得到值 value
     string name = map.get(15937);
     cout << "\n输入学号 15937 ，查询到姓名 " << name << endl;
 

codes/cpp/chapter_hashing/hash_map.cpp

@@ -22,7 +22,7 @@ int main() {
     printHashMap(map);
 
     /* 查询操作 */
-    // 向哈希表输入键 key ，得到值 value
+    // 向哈希表中输入键 key ，得到值 value
     string name = map[15937];
     cout << "\n输入学号 15937 ，查询到姓名 " << name << endl;
 

codes/cpp/chapter_hashing/hash_map_chaining.cpp

@@ -44,13 +44,13 @@ class HashMapChaining {
     /* 查询操作 */
     string get(int key) {
         int index = hashFunc(key);
-        // 遍历桶，若找到 key 则返回对应 val
+        // 遍历桶，若找到 key ，则返回对应 val
         for (Pair *pair : buckets[index]) {
             if (pair->key == key) {
                 return pair->val;
             }
         }
-        // 若未找到 key 则返回空字符串
+        // 若未找到 key ，则返回空字符串
         return "";
     }
 
@@ -136,7 +136,7 @@ int main() {
     map.print();
 
     /* 查询操作 */
-    // 向哈希表输入键 key ，得到值 value
+    // 向哈希表中输入键 key ，得到值 value
     string name = map.get(13276);
     cout << "\n输入学号 13276 ，查询到姓名 " << name << endl;
 

codes/cpp/chapter_hashing/hash_map_open_addressing.cpp

@@ -47,9 +47,9 @@ class HashMapOpenAddressing {
         int firstTombstone = -1;
         // 线性探测，当遇到空桶时跳出
         while (buckets[index] != nullptr) {
-            // 若遇到 key ，返回对应桶索引
+            // 若遇到 key ，返回对应的桶索引
             if (buckets[index]->key == key) {
-                // 若之前遇到了删除标记，则将键值对移动至该索引
+                // 若之前遇到了删除标记，则将键值对移动至该索引处
                 if (firstTombstone != -1) {
                     buckets[firstTombstone] = buckets[index];
                     buckets[index] = TOMBSTONE;
@@ -61,7 +61,7 @@ class HashMapOpenAddressing {
             if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {
                 firstTombstone = index;
             }
-            // 计算桶索引，越过尾部返回头部
+            // 计算桶索引，越过尾部则返回头部
             index = (index + 1) % capacity;
         }
         // 若 key 不存在，则返回添加点的索引
@@ -157,7 +157,7 @@ int main() {
     hashmap.print();
 
     // 查询操作
-    // 向哈希表输入键 key ，得到值 val
+    // 向哈希表中输入键 key ，得到值 val
     string name = hashmap.get(13276);
     cout << "\n输入学号 13276 ，查询到姓名 " << name << endl;
 

codes/cpp/chapter_heap/my_heap.cpp

@@ -12,17 +12,17 @@ class MaxHeap {
     // 使用动态数组，这样无须考虑扩容问题
     vector<int> maxHeap;
 
-    /* 获取左子节点索引 */
+    /* 获取左子节点的索引 */
     int left(int i) {
         return 2 * i + 1;
     }
 
-    /* 获取右子节点索引 */
+    /* 获取右子节点的索引 */
     int right(int i) {
         return 2 * i + 2;
     }
 
-    /* 获取父节点索引 */
+    /* 获取父节点的索引 */
     int parent(int i) {
         return (i - 1) / 2; // 向下整除
     }

codes/cpp/chapter_sorting/bubble_sort.cpp

@@ -36,7 +36,7 @@ void bubbleSortWithFlag(vector<int> &nums) {
             }
         }
         if (!flag)
-            break; // 此轮冒泡未交换任何元素，直接跳出
+            break; // 此轮“冒泡”未交换任何元素，直接跳出
     }
 }
 

codes/cpp/chapter_sorting/merge_sort.cpp

@@ -8,12 +8,12 @@
 
 /* 合并左子数组和右子数组 */
 void merge(vector<int> &nums, int left, int mid, int right) {
-    // 左子数组区间 [left, mid], 右子数组区间 [mid+1, right]
+    // 左子数组区间为 [left, mid], 右子数组区间为 [mid+1, right]
     // 创建一个临时数组 tmp ，用于存放合并后的结果
     vector<int> tmp(right - left + 1);
     // 初始化左子数组和右子数组的起始索引
     int i = left, j = mid + 1, k = 0;
-    // 当左右子数组都还有元素时，比较并将较小的元素复制到临时数组中
+    // 当左右子数组都还有元素时，进行比较并将较小的元素复制到临时数组中
     while (i <= mid && j <= right) {
         if (nums[i] <= nums[j])
             tmp[k++] = nums[i++];

codes/cpp/chapter_sorting/quick_sort.cpp

@@ -55,7 +55,7 @@ class QuickSortMedian {
         nums[j] = tmp;
     }
 
-    /* 选取三个元素的中位数 */
+    /* 选取三个候选元素的中位数 */
     static int medianThree(vector<int> &nums, int left, int mid, int right) {
         // 此处使用异或运算来简化代码
         // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1

codes/cpp/chapter_stack_and_queue/array_deque.cpp

@@ -50,7 +50,7 @@ class ArrayDeque {
             return;
         }
         // 队首指针向左移动一位
-        // 通过取余操作，实现 front 越过数组头部后回到尾部
+        // 通过取余操作实现 front 越过数组头部后回到尾部
         front = index(front - 1);
         // 将 num 添加至队首
         nums[front] = num;
@@ -63,7 +63,7 @@ class ArrayDeque {
             cout << "双向队列已满" << endl;
             return;
         }
-        // 计算尾指针，指向队尾索引 + 1
+        // 计算队尾指针，指向队尾索引 + 1
         int rear = index(front + queSize);
         // 将 num 添加至队尾
         nums[rear] = num;

codes/cpp/chapter_stack_and_queue/array_queue.cpp

@@ -48,7 +48,7 @@ class ArrayQueue {
             return;
         }
         // 计算队尾指针，指向队尾索引 + 1
-        // 通过取余操作，实现 rear 越过数组尾部后回到头部
+        // 通过取余操作实现 rear 越过数组尾部后回到头部
         int rear = (front + queSize) % queCapacity;
         // 将 num 添加至队尾
         nums[rear] = num;
@@ -58,7 +58,7 @@ class ArrayQueue {
     /* 出队 */
     int pop() {
         int num = peek();
-        // 队首指针向后移动一位，若越过尾部则返回到数组头部
+        // 队首指针向后移动一位，若越过尾部，则返回到数组头部
         front = (front + 1) % queCapacity;
         queSize--;
         return num;

codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp

@@ -36,7 +36,7 @@ class LinkedListQueue {
 
     /* 入队 */
     void push(int num) {
-        // 尾节点后添加 num
+        // 在尾节点后添加 num
         ListNode *node = new ListNode(num);
         // 如果队列为空，则令头、尾节点都指向该节点
         if (front == nullptr) {

codes/cpp/chapter_tree/avl_tree.cpp

@@ -79,7 +79,7 @@ class AVLTree {
     TreeNode *insertHelper(TreeNode *node, int val) {
         if (node == nullptr)
             return new TreeNode(val);
-        /* 1. 查找插入位置，并插入节点 */
+        /* 1. 查找插入位置并插入节点 */
         if (val < node->val)
             node->left = insertHelper(node->left, val);
         else if (val > node->val)
@@ -97,7 +97,7 @@ class AVLTree {
     TreeNode *removeHelper(TreeNode *node, int val) {
         if (node == nullptr)
             return nullptr;
-        /* 1. 查找节点，并删除之 */
+        /* 1. 查找节点并删除 */
         if (val < node->val)
             node->left = removeHelper(node->left, val);
         else if (val > node->val)