build

docs/chapter_array_and_linkedlist/array.md

@@ -4,7 +4,7 @@ comments: true
 
 # 4.1   数组
 
-「数组 array」是一种线性数据结构，其将相同类型的元素存储在连续的内存空间中。我们将元素在数组中的位置称为该元素的「索引 index」。图 4-1 展示了数组的主要术语和概念。
+「数组 array」是一种线性数据结构，其将相同类型的元素存储在连续的内存空间中。我们将元素在数组中的位置称为该元素的「索引 index」。图 4-1 展示了数组的主要概念和存储方式。
 
 ![数组定义与存储方式](array.assets/array_definition.png){ class="animation-figure" }
 

docs/chapter_array_and_linkedlist/linked_list.md

@@ -17,8 +17,8 @@ comments: true
 观察图 4-5 ，链表的组成单位是「节点 node」对象。每个节点都包含两项数据：节点的“值”和指向下一节点的“引用”。
 
 - 链表的首个节点被称为“头节点”，最后一个节点被称为“尾节点”。
-- 尾节点指向的是“空”，它在 Java、C++ 和 Python 中分别被记为 $\text{null}$、$\text{nullptr}$ 和 $\text{None}$ 。
-- 在 C、C++、Go 和 Rust 等支持指针的语言中，上述的“引用”应被替换为“指针”。
+- 尾节点指向的是“空”，它在 Java、C++ 和 Python 中分别被记为 `null`、`nullptr` 和 `None` 。
+- 在 C、C++、Go 和 Rust 等支持指针的语言中，上述“引用”应被替换为“指针”。
 
 如以下代码所示，链表节点 `ListNode` 除了包含值，还需额外保存一个引用（指针）。因此在相同数据量下，**链表比数组占用更多的内存空间**。
 
@@ -1119,7 +1119,7 @@ comments: true
 
 如图 4-8 所示，常见的链表类型包括三种。
 
-- **单向链表**：即前面介绍的普通链表。单向链表的节点包含值和指向下一节点的引用两项数据。我们将首个节点称为头节点，将最后一个节点称为尾节点，尾节点指向空 $\text{None}$ 。
+- **单向链表**：即前面介绍的普通链表。单向链表的节点包含值和指向下一节点的引用两项数据。我们将首个节点称为头节点，将最后一个节点称为尾节点，尾节点指向空 `None` 。
 - **环形链表**：如果我们令单向链表的尾节点指向头节点（首尾相接），则得到一个环形链表。在环形链表中，任意节点都可以视作头节点。
 - **双向链表**：与单向链表相比，双向链表记录了两个方向的引用。双向链表的节点定义同时包含指向后继节点（下一个节点）和前驱节点（上一个节点）的引用（指针）。相较于单向链表，双向链表更具灵活性，可以朝两个方向遍历链表，但相应地也需要占用更多的内存空间。
 

docs/chapter_array_and_linkedlist/list.md

@@ -892,7 +892,7 @@ comments: true
 
         def get(self, index: int) -> int:
             """访问元素"""
-            # 索引如果越界则抛出异常，下同
+            # 索引如果越界，则抛出异常，下同
             if index < 0 or index >= self._size:
                 raise IndexError("索引越界")
             return self._arr[index]
@@ -935,12 +935,12 @@ comments: true
                 self._arr[j] = self._arr[j + 1]
             # 更新元素数量
             self._size -= 1
-            # 返回被删除元素
+            # 返回被删除的元素
             return num
 
         def extend_capacity(self):
             """列表扩容"""
-            # 新建一个长度为原数组 __extend_ratio 倍的新数组，并将原数组拷贝到新数组
+            # 新建一个长度为原数组 _extend_ratio 倍的新数组，并将原数组复制到新数组
             self._arr = self._arr + [0] * self.capacity() * (self._extend_ratio - 1)
             # 更新列表容量
             self._capacity = len(self._arr)
@@ -984,7 +984,7 @@ comments: true
 
         /* 访问元素 */
         int get(int index) {
-            // 索引如果越界则抛出异常，下同
+            // 索引如果越界，则抛出异常，下同
             if (index < 0 || index >= size())
                 throw out_of_range("索引越界");
             return arr[index];
@@ -1034,7 +1034,7 @@ comments: true
             }
             // 更新元素数量
             arrSize--;
-            // 返回被删除元素
+            // 返回被删除的元素
             return num;
         }
 
@@ -1092,7 +1092,7 @@ comments: true
 
         /* 访问元素 */
         public int get(int index) {
-            // 索引如果越界则抛出异常，下同
+            // 索引如果越界，则抛出异常，下同
             if (index < 0 || index >= size)
                 throw new IndexOutOfBoundsException("索引越界");
             return arr[index];
@@ -1142,13 +1142,13 @@ comments: true
             }
             // 更新元素数量
             size--;
-            // 返回被删除元素
+            // 返回被删除的元素
             return num;
         }
 
         /* 列表扩容 */
         public void extendCapacity() {
-            // 新建一个长度为原数组 extendRatio 倍的新数组，并将原数组拷贝到新数组
+            // 新建一个长度为原数组 extendRatio 倍的新数组，并将原数组复制到新数组
             arr = Arrays.copyOf(arr, capacity() * extendRatio);
             // 更新列表容量
             capacity = arr.length;
@@ -1194,7 +1194,7 @@ comments: true
 
         /* 访问元素 */
         public int Get(int index) {
-            // 索引如果越界则抛出异常，下同
+            // 索引如果越界，则抛出异常，下同
             if (index < 0 || index >= arrSize)
                 throw new IndexOutOfRangeException("索引越界");
             return arr[index];
@@ -1244,13 +1244,13 @@ comments: true
             }
             // 更新元素数量
             arrSize--;
-            // 返回被删除元素
+            // 返回被删除的元素
             return num;
         }
 
         /* 列表扩容 */
         public void ExtendCapacity() {
-            // 新建一个长度为 arrCapacity * extendRatio 的数组，并将原数组拷贝到新数组
+            // 新建一个长度为 arrCapacity * extendRatio 的数组，并将原数组复制到新数组
             Array.Resize(ref arr, arrCapacity * extendRatio);
             // 更新列表容量
             arrCapacity = arr.Length;
@@ -1301,7 +1301,7 @@ comments: true
 
     /* 访问元素 */
     func (l *myList) get(index int) int {
-        // 索引如果越界则抛出异常，下同
+        // 索引如果越界，则抛出异常，下同
         if index < 0 || index >= l.arrSize {
             panic("索引越界")
         }
@@ -1357,13 +1357,13 @@ comments: true
         }
         // 更新元素数量
         l.arrSize--
-        // 返回被删除元素
+        // 返回被删除的元素
         return num
     }
 
     /* 列表扩容 */
     func (l *myList) extendCapacity() {
-        // 新建一个长度为原数组 extendRatio 倍的新数组，并将原数组拷贝到新数组
+        // 新建一个长度为原数组 extendRatio 倍的新数组，并将原数组复制到新数组
         l.arr = append(l.arr, make([]int, l.arrCapacity*(l.extendRatio-1))...)
         // 更新列表容量
         l.arrCapacity = len(l.arr)
@@ -1460,13 +1460,13 @@ comments: true
             }
             // 更新元素数量
             _size -= 1
-            // 返回被删除元素
+            // 返回被删除的元素
             return num
         }
 
         /* 列表扩容 */
         func extendCapacity() {
-            // 新建一个长度为原数组 extendRatio 倍的新数组，并将原数组拷贝到新数组
+            // 新建一个长度为原数组 extendRatio 倍的新数组，并将原数组复制到新数组
             arr = arr + Array(repeating: 0, count: _capacity * (extendRatio - 1))
             // 更新列表容量
             _capacity = arr.count
@@ -1510,7 +1510,7 @@ comments: true
 
         /* 访问元素 */
         get(index) {
-            // 索引如果越界则抛出异常，下同
+            // 索引如果越界，则抛出异常，下同
             if (index < 0 || index >= this.#size) throw new Error('索引越界');
             return this.#arr[index];
         }
@@ -1558,13 +1558,13 @@ comments: true
             }
             // 更新元素数量
             this.#size--;
-            // 返回被删除元素
+            // 返回被删除的元素
             return num;
         }
 
         /* 列表扩容 */
         extendCapacity() {
-            // 新建一个长度为原数组 extendRatio 倍的新数组，并将原数组拷贝到新数组
+            // 新建一个长度为原数组 extendRatio 倍的新数组，并将原数组复制到新数组
             this.#arr = this.#arr.concat(
                 new Array(this.capacity() * (this.#extendRatio - 1))
             );
@@ -1612,7 +1612,7 @@ comments: true
 
         /* 访问元素 */
         public get(index: number): number {
-            // 索引如果越界则抛出异常，下同
+            // 索引如果越界，则抛出异常，下同
             if (index < 0 || index >= this._size) throw new Error('索引越界');
             return this.arr[index];
         }
@@ -1658,13 +1658,13 @@ comments: true
             }
             // 更新元素数量
             this._size--;
-            // 返回被删除元素
+            // 返回被删除的元素
             return num;
         }
 
         /* 列表扩容 */
         public extendCapacity(): void {
-            // 新建一个长度为 size 的数组，并将原数组拷贝到新数组
+            // 新建一个长度为 size 的数组，并将原数组复制到新数组
             this.arr = this.arr.concat(
                 new Array(this.capacity() * (this.extendRatio - 1))
             );
@@ -1751,7 +1751,7 @@ comments: true
         }
         // 更新元素数量
         _size--;
-        // 返回被删除元素
+        // 返回被删除的元素
         return _num;
       }
 
@@ -1759,7 +1759,7 @@ comments: true
       void extendCapacity() {
         // 新建一个长度为原数组 _extendRatio 倍的新数组
         final _newNums = List.filled(_capacity * _extendRatio, 0);
-        // 将原数组拷贝到新数组
+        // 将原数组复制到新数组
         List.copyRange(_newNums, 0, _arr);
         // 更新 _arr 的引用
         _arr = _newNums;
@@ -1816,7 +1816,7 @@ comments: true
 
         /* 访问元素 */
         pub fn get(&self, index: usize) -> i32 {
-            // 索引如果越界则抛出异常，下同
+            // 索引如果越界，则抛出异常，下同
             if index >= self.size {panic!("索引越界")};
             return self.arr[index];
         }
@@ -1864,13 +1864,13 @@ comments: true
             }
             // 更新元素数量
             self.size -= 1;
-            // 返回被删除元素
+            // 返回被删除的元素
             return num;
         }
 
         /* 列表扩容 */
         pub fn extend_capacity(&mut self) {
-            // 新建一个长度为原数组 extend_ratio 倍的新数组，并将原数组拷贝到新数组
+            // 新建一个长度为原数组 extend_ratio 倍的新数组，并将原数组复制到新数组
             let new_capacity = self.capacity * self.extend_ratio;
             self.arr.resize(new_capacity, 0);
             // 更新列表容量
@@ -2041,14 +2041,14 @@ comments: true
 
             // 访问元素
             pub fn get(self: *Self, index: usize) T {
-                // 索引如果越界则抛出异常，下同
+                // 索引如果越界，则抛出异常，下同
                 if (index < 0 or index >= self.size()) @panic("索引越界");
                 return self.arr[index];
             }  
 
             // 更新元素
             pub fn set(self: *Self, index: usize, num: T) void {
-                // 索引如果越界则抛出异常，下同
+                // 索引如果越界，则抛出异常，下同
                 if (index < 0 or index >= self.size()) @panic("索引越界");
                 self.arr[index] = num;
             }  
@@ -2088,13 +2088,13 @@ comments: true
                 }
                 // 更新元素数量
                 self.numSize -= 1;
-                // 返回被删除元素
+                // 返回被删除的元素
                 return num;
             }
 
             // 列表扩容
             pub fn extendCapacity(self: *Self) !void {
-                // 新建一个长度为 size * extendRatio 的数组，并将原数组拷贝到新数组
+                // 新建一个长度为 size * extendRatio 的数组，并将原数组复制到新数组
                 var newCapacity = self.capacity() * self.extendRatio;
                 var extend = try self.mem_allocator.alloc(T, newCapacity);
                 @memset(extend, @as(T, 0));

docs/chapter_array_and_linkedlist/summary.md

@@ -8,9 +8,8 @@ comments: true
 
 - 数组和链表是两种基本的数据结构，分别代表数据在计算机内存中的两种存储方式：连续空间存储和分散空间存储。两者的特点呈现出互补的特性。
 - 数组支持随机访问、占用内存较少；但插入和删除元素效率低，且初始化后长度不可变。
-- 链表通过更改引用（指针）实现高效的节点插入与删除，且可以灵活调整长度；但节点访问效率低、占用内存较多。
-- 常见的链表类型包括单向链表、环形链表、双向链表，它们分别具有各自的应用场景。
-- 列表是一种支持增删查改的元素有序集合，通常基于动态数组实现，其保留了数组的优势，同时可以灵活调整长度。
+- 链表通过更改引用（指针）实现高效的节点插入与删除，且可以灵活调整长度；但节点访问效率低、占用内存较多。常见的链表类型包括单向链表、环形链表、双向链表。
+- 列表是一种支持增删查改的元素有序集合，通常基于动态数组实现，它保留了数组的优势，同时可以灵活调整长度。
 - 列表的出现大幅地提高了数组的实用性，但可能导致部分内存空间浪费。
 - 程序运行时，数据主要存储在内存中。数组可提供更高的内存空间效率，而链表则在内存使用上更加灵活。
 - 缓存通过缓存行、预取机制以及空间局部性和时间局部性等数据加载机制，为 CPU 提供快速数据访问，显著提升程序的执行效率。
@@ -28,15 +27,15 @@ comments: true
 
 !!! question "为什么数组要求相同类型的元素，而在链表中却没有强调同类型呢？"
 
-    链表由节点组成，节点之间通过引用（指针）连接，各个节点可以存储不同类型的数据，例如 int、double、string、object 等。
+    链表由节点组成，节点之间通过引用（指针）连接，各个节点可以存储不同类型的数据，例如 `int`、`double`、`string`、`object` 等。
 
-    相对地，数组元素则必须是相同类型的，这样才能通过计算偏移量来获取对应元素位置。例如，数组同时包含 int 和 long 两种类型，单个元素分别占用 4 bytes 和 8 bytes ，此时就不能用以下公式计算偏移量了，因为数组中包含了两种长度的元素。
+    相对地，数组元素则必须是相同类型的，这样才能通过计算偏移量来获取对应元素位置。例如，数组同时包含 `int` 和 `long` 两种类型，单个元素分别占用 4 字节 和 8 字节 ，此时就不能用以下公式计算偏移量了，因为数组中包含了两种“元素长度”。
 
     ```shell
     # 元素内存地址 = 数组内存地址 + 元素长度 * 元素索引
     ```
 
-!!! question "删除节点后，是否需要把 `P.next` 设为 $\text{None}$ 呢？"
+!!! question "删除节点后，是否需要把 `P.next` 设为 `None` 呢？"
 
     不修改 `P.next` 也可以。从该链表的角度看，从头节点遍历到尾节点已经不会遇到 `P` 了。这意味着节点 `P` 已经从链表中删除了，此时节点 `P` 指向哪里都不会对该链表产生影响。
 
@@ -50,7 +49,7 @@ comments: true
 
     该示意图只是定性表示，定量表示需要根据具体情况进行分析。
 
-    - 不同类型的节点值占用的空间是不同的，比如 int、long、double 和实例对象等。
+    - 不同类型的节点值占用的空间是不同的，比如 `int`、`long`、`double` 和实例对象等。
     - 指针变量占用的内存空间大小根据所使用的操作系统及编译环境而定，大多为 8 字节或 4 字节。
 
 !!! question "在列表末尾添加元素是否时时刻刻都为 $O(1)$ ？"