Prepare 1.0.0 release (#1044)

krahets · web-flow · commit f6976978dd9e · 2024-01-14T03:16:20.000+08:00
* Update the book with the thrid revised edition

* Fix a typo

* Update the contributors' information

* Update the mindmap

* Update the version number
diff --git a/codes/c/chapter_backtracking/n_queens.c b/codes/c/chapter_backtracking/n_queens.c
@@ -8,7 +8,7 @@
 
 #define MAX_SIZE 100
 
-/* 回溯算法：N 皇后 */
+/* 回溯算法：n 皇后 */
 void backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char ***res, int *resSize, bool cols[MAX_SIZE],
                bool diags1[2 * MAX_SIZE - 1], bool diags2[2 * MAX_SIZE - 1]) {
     // 当放置完所有行时，记录解
@@ -40,7 +40,7 @@ void backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char ***res, int
     }
 }
 
-/* 求解 N 皇后 */
+/* 求解 n 皇后 */
 char ***nQueens(int n, int *returnSize) {
     char state[MAX_SIZE][MAX_SIZE];
     // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
diff --git a/codes/cpp/chapter_backtracking/n_queens.cpp b/codes/cpp/chapter_backtracking/n_queens.cpp
@@ -6,7 +6,7 @@
 
 #include "../utils/common.hpp"
 
-/* 回溯算法：N 皇后 */
+/* 回溯算法：n 皇后 */
 void backtrack(int row, int n, vector<vector<string>> &state, vector<vector<vector<string>>> &res, vector<bool> &cols,
                vector<bool> &diags1, vector<bool> &diags2) {
     // 当放置完所有行时，记录解
@@ -33,7 +33,7 @@ void backtrack(int row, int n, vector<vector<string>> &state, vector<vector<vect
     }
 }
 
-/* 求解 N 皇后 */
+/* 求解 n 皇后 */
 vector<vector<vector<string>>> nQueens(int n) {
     // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
     vector<vector<string>> state(n, vector<string>(n, "#"));
diff --git a/codes/csharp/chapter_backtracking/n_queens.cs b/codes/csharp/chapter_backtracking/n_queens.cs
@@ -7,7 +7,7 @@
 namespace hello_algo.chapter_backtracking;
 
 public class n_queens {
-    /* 回溯算法：N 皇后 */
+    /* 回溯算法：n 皇后 */
     void Backtrack(int row, int n, List<List<string>> state, List<List<List<string>>> res,
             bool[] cols, bool[] diags1, bool[] diags2) {
         // 当放置完所有行时，记录解
@@ -38,7 +38,7 @@ void Backtrack(int row, int n, List<List<string>> state, List<List<List<string>>
         }
     }
 
-    /* 求解 N 皇后 */
+    /* 求解 n 皇后 */
     List<List<List<string>>> NQueens(int n) {
         // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
         List<List<string>> state = [];
diff --git a/codes/dart/chapter_backtracking/n_queens.dart b/codes/dart/chapter_backtracking/n_queens.dart
@@ -4,7 +4,7 @@
  * Author: liuyuxin (gvenusleo@gmail.com)
  */
 
-/* 回溯算法：N 皇后 */
+/* 回溯算法：n 皇后 */
 void backtrack(
   int row,
   int n,
@@ -46,7 +46,7 @@ void backtrack(
   }
 }
 
-/* 求解 N 皇后 */
+/* 求解 n 皇后 */
 List<List<List<String>>> nQueens(int n) {
   // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
   List<List<String>> state = List.generate(n, (index) => List.filled(n, "#"));
diff --git a/codes/go/chapter_backtracking/n_queens.go b/codes/go/chapter_backtracking/n_queens.go
@@ -4,7 +4,7 @@
 
 package chapter_backtracking
 
-/* 回溯算法：N 皇后 */
+/* 回溯算法：n 皇后 */
 func backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {
 	// 当放置完所有行时，记录解
 	if row == n {
@@ -35,6 +35,7 @@ func backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, d
 	}
 }
 
+/* 求解 n 皇后 */
 func nQueens(n int) [][][]string {
 	// 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
 	state := make([][]string, n)
diff --git a/codes/java/chapter_backtracking/n_queens.java b/codes/java/chapter_backtracking/n_queens.java
@@ -9,7 +9,7 @@
 import java.util.*;
 
 public class n_queens {
-    /* 回溯算法：N 皇后 */
+    /* 回溯算法：n 皇后 */
     public static void backtrack(int row, int n, List<List<String>> state, List<List<List<String>>> res,
             boolean[] cols, boolean[] diags1, boolean[] diags2) {
         // 当放置完所有行时，记录解
@@ -40,7 +40,7 @@ public static void backtrack(int row, int n, List<List<String>> state, List<List
         }
     }
 
-    /* 求解 N 皇后 */
+    /* 求解 n 皇后 */
     public static List<List<List<String>>> nQueens(int n) {
         // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
         List<List<String>> state = new ArrayList<>();
diff --git a/codes/javascript/chapter_backtracking/n_queens.js b/codes/javascript/chapter_backtracking/n_queens.js
@@ -4,7 +4,7 @@
  * Author: Justin (xiefahit@gmail.com)
  */
 
-/* 回溯算法：N 皇后 */
+/* 回溯算法：n 皇后 */
 function backtrack(row, n, state, res, cols, diags1, diags2) {
     // 当放置完所有行时，记录解
     if (row === n) {
@@ -30,7 +30,7 @@ function backtrack(row, n, state, res, cols, diags1, diags2) {
     }
 }
 
-/* 求解 N 皇后 */
+/* 求解 n 皇后 */
 function nQueens(n) {
     // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
     const state = Array.from({ length: n }, () => Array(n).fill('#'));
diff --git a/codes/python/chapter_backtracking/n_queens.py b/codes/python/chapter_backtracking/n_queens.py
@@ -14,7 +14,7 @@ def backtrack(
     diags1: list[bool],
     diags2: list[bool],
 ):
-    """回溯算法：N 皇后"""
+    """回溯算法：n 皇后"""
     # 当放置完所有行时，记录解
     if row == n:
         res.append([list(row) for row in state])
@@ -37,7 +37,7 @@ def backtrack(
 
 
 def n_queens(n: int) -> list[list[list[str]]]:
-    """求解 N 皇后"""
+    """求解 n 皇后"""
     # 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
     state = [["#" for _ in range(n)] for _ in range(n)]
     cols = [False] * n  # 记录列是否有皇后
diff --git a/codes/rust/chapter_backtracking/n_queens.rs b/codes/rust/chapter_backtracking/n_queens.rs
@@ -4,7 +4,7 @@
  * Author: codingonion (coderonion@gmail.com)
  */
 
-/* 回溯算法：N 皇后 */
+/* 回溯算法：n 皇后 */
 fn backtrack(row: usize, n: usize, state: &mut Vec<Vec<String>>, res: &mut Vec<Vec<Vec<String>>>,
     cols: &mut [bool], diags1: &mut [bool], diags2: &mut [bool]) {
     // 当放置完所有行时，记录解
@@ -35,7 +35,7 @@ fn backtrack(row: usize, n: usize, state: &mut Vec<Vec<String>>, res: &mut Vec<V
     }
 }
 
-/* 求解 N 皇后 */
+/* 求解 n 皇后 */
 fn n_queens(n: usize) -> Vec<Vec<Vec<String>>> {
     // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
     let mut state: Vec<Vec<String>> = Vec::new();
diff --git a/codes/swift/chapter_backtracking/n_queens.swift b/codes/swift/chapter_backtracking/n_queens.swift
@@ -4,7 +4,7 @@
  * Author: nuomi1 (nuomi1@qq.com)
  */
 
-/* 回溯算法：N 皇后 */
+/* 回溯算法：n 皇后 */
 func backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) {
     // 当放置完所有行时，记录解
     if row == n {
@@ -34,7 +34,7 @@ func backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]
     }
 }
 
-/* 求解 N 皇后 */
+/* 求解 n 皇后 */
 func nQueens(n: Int) -> [[[String]]] {
     // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
     var state = Array(repeating: Array(repeating: "#", count: n), count: n)
diff --git a/codes/typescript/chapter_backtracking/n_queens.ts b/codes/typescript/chapter_backtracking/n_queens.ts
@@ -4,7 +4,7 @@
  * Author: Justin (xiefahit@gmail.com)
  */
 
-/* 回溯算法：N 皇后 */
+/* 回溯算法：n 皇后 */
 function backtrack(
     row: number,
     n: number,
@@ -38,7 +38,7 @@ function backtrack(
     }
 }
 
-/* 求解 N 皇后 */
+/* 求解 n 皇后 */
 function nQueens(n: number): string[][][] {
     // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
     const state = Array.from({ length: n }, () => Array(n).fill('#'));
diff --git a/docs-en/chapter_preface/about_the_book.md b/docs-en/chapter_preface/about_the_book.md
@@ -30,7 +30,7 @@ The main content of the book is shown in the following figure.
 
 ## Acknowledgements
 
-This book is continuously improved with the joint efforts of many contributors from the open-source community. Thanks to each writer who invested their time and energy, listed in the order generated by GitHub: krahets、codingonion、nuomi1、Gonglja、Reanon、justin-tse、danielsss、hpstory、S-N-O-R-L-A-X、night-cruise、msk397、gvenusleo、RiverTwilight、gyt95、zhuoqinyue、Zuoxun、Xia-Sang、mingXta、FangYuan33、GN-Yu、IsChristina、xBLACKICEx、guowei-gong、Cathay-Chen、mgisr、JoseHung、qualifier1024、pengchzn、Guanngxu、longsizhuo、L-Super、what-is-me、yuan0221、lhxsm、Slone123c、WSL0809、longranger2、theNefelibatas、xiongsp、JeffersonHuang、hongyun-robot、K3v123、yuelinxin、a16su、gaofer、malone6、Wonderdch、xjr7670、DullSword、Horbin-Magician、NI-SW、reeswell、XC-Zero、XiaChuerwu、yd-j、iron-irax、huawuque404、MolDuM、Nigh、KorsChen、foursevenlove、52coder、bubble9um、youshaoXG、curly210102、gltianwen、fanchenggang、Transmigration-zhou、FloranceYeh、FreddieLi、ShiMaRing、lipusheng、Javesun99、JackYang-hellobobo、shanghai-Jerry、0130w、Keynman、psychelzh、logan-qiu、ZnYang2018、MwumLi、1ch0、Phoenix0415、qingpeng9802、Richard-Zhang1019、QiLOL、Suremotoo、Turing-1024-Lee、Evilrabbit520、GaochaoZhu、ZJKung、linzeyan、hezhizhen、ZongYangL、beintentional、czruby、coderlef、dshlstarr、szu17dmy、fbigm、gledfish、hts0000、boloboloda、iStig、jiaxianhua、wenjianmin、keshida、kilikilikid、lclc6、lwbaptx、liuxjerry、lucaswangdev、lyl625760、chadyi、noobcodemaker、selear、siqyka、syd168、4yDX3906、tao363、wangwang105、weibk、yabo083、yi427、yishangzhang、zhouLion、baagod、ElaBosak233、xb534、luluxia、yanedie、thomasq0 和 YangXuanyi。
+This book is continuously improved with the joint efforts of many contributors from the open-source community. Thanks to each writer who invested their time and energy, listed in the order generated by GitHub: krahets, codingonion, nuomi1, Gonglja, Reanon, justin-tse, danielsss, hpstory, S-N-O-R-L-A-X, night-cruise, msk397, gvenusleo, RiverTwilight, gyt95, zhuoqinyue, Zuoxun, Xia-Sang, mingXta, FangYuan33, GN-Yu, IsChristina, xBLACKICEx, guowei-gong, Cathay-Chen, mgisr, JoseHung, qualifier1024, pengchzn, Guanngxu, longsizhuo, L-Super, what-is-me, yuan0221, lhxsm, Slone123c, WSL0809, longranger2, theNefelibatas, xiongsp, JeffersonHuang, hongyun-robot, K3v123, yuelinxin, a16su, gaofer, malone6, Wonderdch, xjr7670, DullSword, Horbin-Magician, NI-SW, reeswell, XC-Zero, XiaChuerwu, yd-j, iron-irax, huawuque404, MolDuM, Nigh, KorsChen, foursevenlove, 52coder, bubble9um, youshaoXG, curly210102, gltianwen, fanchenggang, Transmigration-zhou, FloranceYeh, FreddieLi, ShiMaRing, lipusheng, Javesun99, JackYang-hellobobo, shanghai-Jerry, 0130w, Keynman, psychelzh, logan-qiu, ZnYang2018, MwumLi, 1ch0, Phoenix0415, qingpeng9802, Richard-Zhang1019, QiLOL, Suremotoo, Turing-1024-Lee, Evilrabbit520, GaochaoZhu, ZJKung, linzeyan, hezhizhen, ZongYangL, beintentional, czruby, coderlef, dshlstarr, szu17dmy, fbigm, gledfish, hts0000, boloboloda, iStig, jiaxianhua, wenjianmin, keshida, kilikilikid, lclc6, lwbaptx, liuxjerry, lucaswangdev, lyl625760, chadyi, noobcodemaker, selear, siqyka, syd168, 4yDX3906, tao363, wangwang105, weibk, yabo083, yi427, yishangzhang, zhouLion, baagod, ElaBosak233, xb534, luluxia, yanedie, thomasq0, YangXuanyi and th1nk3r-ing.
 
 The code review work for this book was completed by codingonion, Gonglja, gvenusleo, hpstory, justin‐tse, krahets, night-cruise, nuomi1, and Reanon (listed in alphabetical order). Thanks to them for their time and effort, ensuring the standardization and uniformity of the code in various languages.
 
diff --git a/docs/chapter_appendix/terminology.md b/docs/chapter_appendix/terminology.md
@@ -53,7 +53,7 @@
 | 根节点         | root node                      | 剪枝           | pruning                     |
 | 叶节点         | leaf node                      | 全排列问题     | permutations problem        |
 | 边             | edge                           | 子集和问题     | subset-sum problem          |
-| 层             | level                          | N 皇后问题     | N-queens problem            |
+| 层             | level                          | n 皇后问题     | n-queens problem            |
 | 度             | degree                         | 动态规划       | dynamic programming         |
 | 高度           | height                         | 初始状态       | initial state               |
 | 深度           | depth                          | 状态转移方程   | state-trasition equation    |
diff --git a/docs/chapter_array_and_linkedlist/summary.md b/docs/chapter_array_and_linkedlist/summary.md
@@ -5,8 +5,8 @@
 - 数组和链表是两种基本的数据结构，分别代表数据在计算机内存中的两种存储方式：连续空间存储和分散空间存储。两者的特点呈现出互补的特性。
 - 数组支持随机访问、占用内存较少；但插入和删除元素效率低，且初始化后长度不可变。
 - 链表通过更改引用（指针）实现高效的节点插入与删除，且可以灵活调整长度；但节点访问效率低、占用内存较多。常见的链表类型包括单向链表、环形链表、双向链表。
-- 列表是一种支持增删查改的元素有序集合，通常基于动态数组实现，它保留了数组的优势，同时可以灵活调整长度。
-- 列表的出现大幅地提高了数组的实用性，但可能导致部分内存空间浪费。
+- 列表是一种支持增删查改的元素有序集合，通常基于动态数组实现。它保留了数组的优势，同时可以灵活调整长度。
+- 列表的出现大幅提高了数组的实用性，但可能导致部分内存空间浪费。
 - 程序运行时，数据主要存储在内存中。数组可提供更高的内存空间效率，而链表则在内存使用上更加灵活。
 - 缓存通过缓存行、预取机制以及空间局部性和时间局部性等数据加载机制，为 CPU 提供快速数据访问，显著提升程序的执行效率。
 - 由于数组具有更高的缓存命中率，因此它通常比链表更高效。在选择数据结构时，应根据具体需求和场景做出恰当选择。
@@ -21,14 +21,14 @@
 2. 大小限制：栈内存相对较小，堆的大小一般受限于可用内存。因此堆更加适合存储大型数组。
 3. 灵活性：栈上的数组的大小需要在编译时确定，而堆上的数组的大小可以在运行时动态确定。
 
-**Q**：为什么数组要求相同类型的元素，而在链表中却没有强调同类型呢？
+**Q**：为什么数组要求相同类型的元素，而在链表中却没有强调相同类型呢？
 
 链表由节点组成，节点之间通过引用（指针）连接，各个节点可以存储不同类型的数据，例如 `int`、`double`、`string`、`object` 等。
 
 相对地，数组元素则必须是相同类型的，这样才能通过计算偏移量来获取对应元素位置。例如，数组同时包含 `int` 和 `long` 两种类型，单个元素分别占用 4 字节 和 8 字节 ，此时就不能用以下公式计算偏移量了，因为数组中包含了两种“元素长度”。
 
 ```shell
-# 元素内存地址 = 数组内存地址 + 元素长度 * 元素索引
+# 元素内存地址 = 数组内存地址（首元素内存地址） + 元素长度 * 元素索引
 ```
 
 **Q**：删除节点后，是否需要把 `P.next` 设为 `None` 呢？
diff --git a/docs/chapter_backtracking/n_queens_problem.md b/docs/chapter_backtracking/n_queens_problem.md
@@ -1,4 +1,4 @@
-# N 皇后问题
+# n 皇后问题
 
 !!! question
 
diff --git a/docs/chapter_computational_complexity/performance_evaluation.md b/docs/chapter_computational_complexity/performance_evaluation.md
@@ -10,7 +10,7 @@
 - **时间效率**：算法运行速度的快慢。
 - **空间效率**：算法占用内存空间的大小。
 
-简而言之，**我们的目标是设计“既快又省”的数据结构与算法**。而有效地评估算法效率至关重要，因为只有这样我们才能将各种算法进行对比，进而指导算法设计与优化过程。
+简而言之，**我们的目标是设计“既快又省”的数据结构与算法**。而有效地评估算法效率至关重要，因为只有这样，我们才能将各种算法进行对比，进而指导算法设计与优化过程。
 
 效率评估方法主要分为两种：实际测试、理论估算。
 
diff --git a/docs/chapter_data_structure/number_encoding.md b/docs/chapter_data_structure/number_encoding.md
@@ -90,7 +90,7 @@ $$
 
 细心的你可能会发现：`int` 和 `float` 长度相同，都是 4 字节 ，但为什么 `float` 的取值范围远大于 `int` ？这非常反直觉，因为按理说 `float` 需要表示小数，取值范围应该变小才对。
 
-实际上，**这是因为浮点数 `float` 采用了不同的表示方式**。记一个 32 位长度的二进制数为：
+实际上，**这是因为浮点数 `float` 采用了不同的表示方式**。记一个 32 比特长度的二进制数为：
 
 $$
 b_{31} b_{30} b_{29} \ldots b_2 b_1 b_0
@@ -133,7 +133,7 @@ $$
 
 现在我们可以回答最初的问题：**`float` 的表示方式包含指数位，导致其取值范围远大于 `int`** 。根据以上计算，`float` 可表示的最大正数为 $2^{254 - 127} \times (2 - 2^{-23}) \approx 3.4 \times 10^{38}$ ，切换符号位便可得到最小负数。
 
-**尽管浮点数 `float` 扩展了取值范围，但其副作用是牺牲了精度**。整数类型 `int` 将全部 32 位用于表示数字，数字是均匀分布的；而由于指数位的存在，浮点数 `float` 的数值越大，相邻两个数字之间的差值就会趋向越大。
+**尽管浮点数 `float` 扩展了取值范围，但其副作用是牺牲了精度**。整数类型 `int` 将全部 32 比特用于表示数字，数字是均匀分布的；而由于指数位的存在，浮点数 `float` 的数值越大，相邻两个数字之间的差值就会趋向越大。
 
 如下表所示，指数位 $E = 0$ 和 $E = 255$ 具有特殊含义，**用于表示零、无穷大、$\mathrm{NaN}$ 等**。
 
diff --git a/docs/chapter_data_structure/summary.md b/docs/chapter_data_structure/summary.md
@@ -6,7 +6,7 @@
 - 常见的逻辑结构包括线性、树状和网状等。通常我们根据逻辑结构将数据结构分为线性（数组、链表、栈、队列）和非线性（树、图、堆）两种。哈希表的实现可能同时包含线性数据结构和非线性数据结构。
 - 当程序运行时，数据被存储在计算机内存中。每个内存空间都拥有对应的内存地址，程序通过这些内存地址访问数据。
 - 物理结构主要分为连续空间存储（数组）和分散空间存储（链表）。所有数据结构都是由数组、链表或两者的组合实现的。
-- 计算机中的基本数据类型包括整数 `byte`、`short`、`int`、`long` ，浮点数 `float`、`double` ，字符 `char` 和布尔 `boolean` 。它们的取值范围取决于占用空间大小和表示方式。
+- 计算机中的基本数据类型包括整数 `byte`、`short`、`int`、`long` ，浮点数 `float`、`double` ，字符 `char` 和布尔 `bool` 。它们的取值范围取决于占用空间大小和表示方式。
 - 原码、反码和补码是在计算机中编码数字的三种方法，它们之间可以相互转换。整数的原码的最高位是符号位，其余位是数字的值。
 - 整数在计算机中是以补码的形式存储的。在补码表示下，计算机可以对正数和负数的加法一视同仁，不需要为减法操作单独设计特殊的硬件电路，并且不存在正负零歧义的问题。
 - 浮点数的编码由 1 位符号位、8 位指数位和 23 位分数位构成。由于存在指数位，因此浮点数的取值范围远大于整数，代价是牺牲了精度。
diff --git a/docs/chapter_divide_and_conquer/build_binary_tree_problem.md b/docs/chapter_divide_and_conquer/build_binary_tree_problem.md
@@ -2,7 +2,7 @@
 
 !!! question
 
-    给定一棵二叉树的前序遍历 `preorder` 和中序遍历 `inorder` ，请从中构建二叉树，返回二叉树的根节点。假设二叉树中没有值重复的节点，如下图所示。
+    给定一棵二叉树的前序遍历 `preorder` 和中序遍历 `inorder` ，请从中构建二叉树，返回二叉树的根节点。假设二叉树中没有值重复的节点（如下图所示）。
 
 ![构建二叉树的示例数据](build_binary_tree_problem.assets/build_tree_example.png)
 
diff --git a/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md b/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md
@@ -2,7 +2,7 @@
 
 在本节中，我们先求解另一个常见的背包问题：完全背包，再了解它的一种特例：零钱兑换。
 
-## 完全背包
+## 完全背包问题
 
 !!! question
 
diff --git a/docs/chapter_graph/graph.md b/docs/chapter_graph/graph.md
@@ -14,7 +14,7 @@ $$
 
 ![链表、树、图之间的关系](graph.assets/linkedlist_tree_graph.png)
 
-## 图常见类型与术语
+## 图的常见类型与术语
 
 根据边是否具有方向，可分为「无向图 undirected graph」和「有向图 directed graph」，如下图所示。
 
diff --git a/docs/chapter_graph/graph_operations.md b/docs/chapter_graph/graph_operations.md
@@ -1,4 +1,4 @@
-# 图基础操作
+# 图的基础操作
 
 图的基础操作可分为对“边”的操作和对“顶点”的操作。在“邻接矩阵”和“邻接表”两种表示方法下，实现方式有所不同。
 
diff --git a/docs/chapter_preface/about_the_book.assets/hello_algo_mindmap.png b/docs/chapter_preface/about_the_book.assets/hello_algo_mindmap.png
diff --git a/docs/chapter_preface/about_the_book.md b/docs/chapter_preface/about_the_book.md
diff --git a/docs/chapter_preface/suggestions.md b/docs/chapter_preface/suggestions.md
diff --git a/docs/chapter_searching/binary_search.md b/docs/chapter_searching/binary_search.md
diff --git a/docs/chapter_sorting/heap_sort.md b/docs/chapter_sorting/heap_sort.md
diff --git a/docs/chapter_stack_and_queue/stack.md b/docs/chapter_stack_and_queue/stack.md
diff --git a/docs/chapter_stack_and_queue/summary.md b/docs/chapter_stack_and_queue/summary.md
diff --git a/docs/chapter_tree/avl_tree.md b/docs/chapter_tree/avl_tree.md
diff --git a/docs/index.md b/docs/index.md
diff --git a/mkdocs-en.yml b/mkdocs-en.yml
diff --git a/mkdocs.yml b/mkdocs.yml

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@`
`8`	`8`
`9`	`9`	`#define MAX_SIZE 100`
`10`	`10`
`11`		`-/* 回溯算法：N 皇后 */`
	`11`	`+/* 回溯算法：n 皇后 */`
`12`	`12`	`void backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char **res, int resSize, bool cols[MAX_SIZE],`
`13`	`13`	`bool diags1[2 * MAX_SIZE - 1], bool diags2[2 * MAX_SIZE - 1]) {`
`14`	`14`	`// 当放置完所有行时，记录解`
`@@ -40,7 +40,7 @@ void backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char ***res, int`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`43`		`-/* 求解 N 皇后 */`
	`43`	`+/* 求解 n 皇后 */`
`44`	`44`	`char **nQueens(int n, int returnSize) {`
`45`	`45`	`char state[MAX_SIZE][MAX_SIZE];`
`46`	`46`	`// 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`
`7`	`7`	`#include "../utils/common.hpp"`
`8`	`8`
`9`		`-/* 回溯算法：N 皇后 */`
	`9`	`+/* 回溯算法：n 皇后 */`
`10`	`10`	`void backtrack(int row, int n, vector<vector<string>> &state, vector<vector<vector<string>>> &res, vector<bool> &cols,`
`11`	`11`	`vector<bool> &diags1, vector<bool> &diags2) {`
`12`	`12`	`// 当放置完所有行时，记录解`
`@@ -33,7 +33,7 @@ void backtrack(int row, int n, vector<vector<string>> &state, vector<vector<vect`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`
`36`		`-/* 求解 N 皇后 */`
	`36`	`+/* 求解 n 皇后 */`
`37`	`37`	`vector<vector<vector<string>>> nQueens(int n) {`
`38`	`38`	`// 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位`
`39`	`39`	`vector<vector<string>> state(n, vector<string>(n, "#"));`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`package chapter_backtracking`
`6`	`6`
`7`		`-/* 回溯算法：N 皇后 */`
	`7`	`+/* 回溯算法：n 皇后 */`
`8`	`8`	`func backtrack(row, n int, state [][]string, res [][][]string, cols, diags1, diags2 *[]bool) {`
`9`	`9`	`// 当放置完所有行时，记录解`
`10`	`10`	`if row == n {`
`@@ -35,6 +35,7 @@ func backtrack(row, n int, state [][]string, res [][][]string, cols, diags1, d`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`
	`38`	`+/* 求解 n 皇后 */`
`38`	`39`	`func nQueens(n int) [][][]string {`
`39`	`40`	`// 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位`
`40`	`41`	`state := make([][]string, n)`