Remove the spaces between “ ” and 中文 aside.

docs/chapter_array_and_linkedlist/linked_list.md

@@ -613,7 +613,7 @@ comments: true
         int val;         // 结点值
         ListNode *next;  // 指向后继结点的指针（引用）
         ListNode *prev;  // 指向前驱结点的指针（引用）
-        ListNode(int x) : val(x), next(nullptr) {}  // 构造函数
+        ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // 构造函数
     };
     ```
 
@@ -644,8 +644,8 @@ comments: true
         prev;
         constructor(val, next) {
             this.val = val  ===  undefined ? 0 : val;        // 结点值
-            this.next = next  ===  undefined ? null : next;  // 指向后继结点的引用
-            this.prev = prev  ===  undefined ? null : prev;  // 指向前驱结点的引用
+            this.next = next  ===  undefined ? null : next;  // 指向后继结点的指针（引用）
+            this.prev = prev  ===  undefined ? null : prev;  // 指向前驱结点的指针（引用）
         }
     }
     ```
@@ -660,8 +660,8 @@ comments: true
         prev: ListNode | null;
         constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {
             this.val = val  ===  undefined ? 0 : val;        // 结点值
-            this.next = next  ===  undefined ? null : next;  // 指向后继结点的引用
-            this.prev = prev  ===  undefined ? null : prev;  // 指向前驱结点的引用
+            this.next = next  ===  undefined ? null : next;  // 指向后继结点的指针（引用）
+            this.prev = prev  ===  undefined ? null : prev;  // 指向前驱结点的指针（引用）
         }
     }
     ```

docs/chapter_array_and_linkedlist/list.md

@@ -10,13 +10,15 @@ comments: true
 
 ## 列表常用操作
 
-**初始化列表。** 我们通常使用 `Integer[]` 包装类和 `Arrays.asList()` 作为中转，来初始化一个带有初始值的列表。
+**初始化列表。** 我们通常会使用到“无初始值”和“有初始值”的两种初始化方法。
 
 === "Java"
 
     ```java title="list.java"
     /* 初始化列表 */
-    // 注意数组的元素类型是 int[] 的包装类 Integer[]
+    // 无初始值
+    List<Integer> list1 = new ArrayList<>();
+    // 有初始值（注意数组的元素类型需为 int[] 的包装类 Integer[]）
     Integer[] numbers = new Integer[] { 1, 3, 2, 5, 4 };
     List<Integer> list = new ArrayList<>(Arrays.asList(numbers));
     ```
@@ -25,6 +27,10 @@ comments: true
 
     ```cpp title="list.cpp"
     /* 初始化列表 */
+    // 需注意，C++ 中 vector 即是本文描述的 list
+    // 无初始值
+    vector<int> list1;
+    // 有初始值
     vector<int> list = { 1, 3, 2, 5, 4 };
     ```
 
@@ -32,6 +38,9 @@ comments: true
 
     ```python title="list.py"
     """ 初始化列表 """
+    # 无初始值
+    list1 = []
+    # 有初始值
     list = [1, 3, 2, 5, 4]
     ```
 
@@ -39,6 +48,9 @@ comments: true
 
     ```go title="list_test.go"
     /* 初始化列表 */
+    // 无初始值
+    list1 := []int
+    // 有初始值
     list := []int{1, 3, 2, 5, 4}
     ```
 
@@ -46,6 +58,9 @@ comments: true
 
     ```js title="list.js"
     /* 初始化列表 */
+    // 无初始值
+    const list1 = [];
+    // 有初始值
     const list = [1, 3, 2, 5, 4];
     ```
 
@@ -53,6 +68,9 @@ comments: true
 
     ```typescript title="list.ts"
     /* 初始化列表 */
+    // 无初始值
+    const list1: number[] = [];
+    // 有初始值
     const list: number[] = [1, 3, 2, 5, 4];
     ```
 

docs/chapter_hashing/hash_map.md

@@ -6,7 +6,7 @@ comments: true
 
 哈希表通过建立「键 key」和「值 value」之间的映射，实现高效的元素查找。具体地，输入一个 key ，在哈希表中查询并获取 value ，时间复杂度为 $O(1)$ 。
 
-例如，给定一个包含 $n$ 个学生的数据库，每个学生有 "姓名 `name` ” 和 “学号 `id` ” 两项数据，希望实现一个查询功能：**输入一个学号，返回对应的姓名**，则可以使用哈希表实现。
+例如，给定一个包含 $n$ 个学生的数据库，每个学生有“姓名 `name` ”和“学号 `id` ”两项数据，希望实现一个查询功能：**输入一个学号，返回对应的姓名**，则可以使用哈希表实现。
 
 ![hash_map](hash_map.assets/hash_map.png)
 

docs/chapter_tree/binary_search_tree.md

@@ -668,7 +668,7 @@ comments: true
 - **删除元素：** 与无序数组中的情况相同，使用 $O(n)$ 时间；
 - **获取最小 / 最大元素：** 数组头部和尾部元素即是最小和最大元素，使用 $O(1)$ 时间；
 
-观察发现，无序数组和有序数组中的各类操作的时间复杂度是 “偏科” 的，即有的快有的慢；**而二叉搜索树的各项操作的时间复杂度都是对数阶，在数据量 $n$ 很大时有巨大优势**。
+观察发现，无序数组和有序数组中的各项操作的时间复杂度是“偏科”的，即有的快有的慢；**而二叉搜索树的各项操作的时间复杂度都是对数阶，在数据量 $n$ 很大时有巨大优势**。
 
 <div class="center-table" markdown>