Polish the chapter of array and linkedlist

2026-04-05 03:30:30 +08:00 · 2023-08-17 05:13:19 +08:00
parent 0858ab91c0
commit c310edb672
26 changed files with 287 additions and 236 deletions
--- a/docs/chapter_array_and_linkedlist/array.md
+++ b/docs/chapter_array_and_linkedlist/array.md
@@ -1,10 +1,14 @@
 # 数组

-「数组 Array」是一种线性数据结构，其将相同类型元素存储在连续的内存空间中。我们将元素在数组中的位置称为元素的「索引 Index」。
+「数组 Array」是一种线性数据结构，其将相同类型元素存储在连续的内存空间中。我们将某个元素在数组中的位置称为该元素的「索引 Index」。

 ![数组定义与存储方式](array.assets/array_definition.png)

-**数组初始化**。通常有无初始值和给定初始值两种方式，我们可根据需求选择合适的方法。在大多数编程语言中，若未指定初始值，数组的所有元素通常会被默认初始化为 $0$ 。
+## 数组常用操作
+
+### 初始化数组
+
+我们可以根据需求选用数组的两种初始化方式：无初始值、给定初始值。在未指定初始值的情况下，大多数编程语言会将数组元素初始化为 $0$ 。

 === "Java"

@@ -21,7 +25,7 @@
    // 存储在栈上
    int arr[5];
    int nums[5] { 1, 3, 2, 5, 4 };
-    // 存储在堆上
+    // 存储在堆上（需要手动释放空间）
    int* arr1 = new int[5];
    int* nums1 = new int[5] { 1, 3, 2, 5, 4 };
    ```
@@ -108,24 +112,20 @@
    let nums: Vec<i32> = vec![1, 3, 2, 5, 4];
    ```

-## 数组优点
+### 访问元素

-**在数组中访问元素非常高效**。由于数组元素被存储在连续的内存空间中，因此计算数组元素的内存地址非常容易。给定数组首个元素的地址和某个元素的索引，我们可以使用以下公式计算得到该元素的内存地址，从而直接访问此元素。
-
-![数组元素的内存地址计算](array.assets/array_memory_location_calculation.png)
+数组元素被存储在连续的内存空间中，这意味着计算数组元素的内存地址非常容易。给定数组内存地址（即首元素内存地址）和某个元素的索引，我们可以使用以下公式计算得到该元素的内存地址，从而直接访问此元素。

 ```shell
-# 元素内存地址 = 数组内存地址 + 元素长度 * 元素索引
+# 元素内存地址 = 数组内存地址（首元素内存地址） + 元素长度 * 元素索引
 elementAddr = firtstElementAddr + elementLength * elementIndex
 ```

-!!! question "为什么数组元素的索引要从 $0$ 开始编号呢？"
+![数组元素的内存地址计算](array.assets/array_memory_location_calculation.png)

-    观察上图，我们发现数组首个元素的索引为 $0$ ，这似乎有些反直觉，因为从 $1$ 开始计数会更自然。
-    
-    然而从地址计算公式的角度看，**索引本质上表示的是内存地址的偏移量**。首个元素的地址偏移量是 $0$ ，因此索引为 $0$ 也是合理的。
+观察上图，我们发现数组首个元素的索引为 $0$ ，这似乎有些反直觉，因为从 $1$ 开始计数会更自然。但从地址计算公式的角度看，**索引的含义本质上是内存地址的偏移量**。首个元素的地址偏移量是 $0$ ，因此它的索引为 $0$ 也是合理的。

-访问元素的高效性带来了诸多便利。例如，我们可以在 $O(1)$ 时间内随机获取数组中的任意一个元素。
+在数组中访问元素是非常高效的，我们可以在 $O(1)$ 时间内随机访问数组中的任意一个元素。

 === "Java"

@@ -199,83 +199,11 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
    [class]{}-[func]{random_access}
    ```

-## 数组缺点
+### 插入元素

-**数组在初始化后长度不可变**。系统无法保证数组之后的内存空间是可用的，因此数组长度无法扩展。而若希望扩容数组，则需新建一个数组，然后把原数组元素依次拷贝到新数组。在数组很大的情况下，这是非常耗时的。
+数组元素在内存中是“紧挨着的”，它们之间没有空间再存放任何数据。这意味着如果想要在数组中间插入一个元素，则需要将该元素之后的所有元素都向后移动一位，之后再把元素赋值给该索引。

-=== "Java"
-
-    ```java title="array.java"
-    [class]{array}-[func]{extend}
-    ```
-
-=== "C++"
-
-    ```cpp title="array.cpp"
-    [class]{}-[func]{extend}
-    ```
-
-=== "Python"
-
-    ```python title="array.py"
-    [class]{}-[func]{extend}
-    ```
-
-=== "Go"
-
-    ```go title="array.go"
-    [class]{}-[func]{extend}
-    ```
-
-=== "JS"
-
-    ```javascript title="array.js"
-    [class]{}-[func]{extend}
-    ```
-
-=== "TS"
-
-    ```typescript title="array.ts"
-    [class]{}-[func]{extend}
-    ```
-
-=== "C"
-
-    ```c title="array.c"
-    [class]{}-[func]{extend}
-    ```
-
-=== "C#"
-
-    ```csharp title="array.cs"
-    [class]{array}-[func]{extend}
-    ```
-
-=== "Swift"
-
-    ```swift title="array.swift"
-    [class]{}-[func]{extend}
-    ```
-
-=== "Zig"
-
-    ```zig title="array.zig"
-    [class]{}-[func]{extend}
-    ```
-
-=== "Dart"
-
-    ```dart title="array.dart"
-    [class]{}-[func]{extend}
-    ```
-
-=== "Rust"
-
-    ```rust title="array.rs"
-    [class]{}-[func]{extend}
-    ```
-
-**数组中插入或删除元素效率低下**。数组元素在内存中是“紧挨着的”，它们之间没有空间再放任何数据。这意味着如果我们想要在数组中间插入一个元素，就不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。
+值得注意的是，由于数组的长度是固定的，因此插入一个元素必定会导致数组尾部元素的“丢失”。我们将这个问题的解决方案留在列表章节中讨论。

 ![数组插入元素](array.assets/array_insert_element.png)

@@ -351,7 +279,11 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
    [class]{}-[func]{insert}
    ```

-删除元素也类似，如果我们想要删除索引 $i$ 处的元素，则需要把索引 $i$ 之后的元素都向前移动一位。值得注意的是，删除元素后，原先末尾的元素变得“无意义”了，所以我们无需特意去修改它。
+### 删除元素
+
+同理，如果我们想要删除索引 $i$ 处的元素，则需要把索引 $i$ 之后的元素都向前移动一位。
+
+请注意，删除元素完成后，原先末尾的元素变得“无意义”了，所以我们无需特意去修改它。

 ![数组删除元素](array.assets/array_remove_element.png)

@@ -427,15 +359,15 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
    [class]{}-[func]{remove}
    ```

-总结来看，数组的插入与删除操作有以下缺点：
+总的来看，数组的插入与删除操作有以下缺点：

 - **时间复杂度高**：数组的插入和删除的平均时间复杂度均为 $O(n)$ ，其中 $n$ 为数组长度。
 - **丢失元素**：由于数组的长度不可变，因此在插入元素后，超出数组长度范围的元素会丢失。
- **内存浪费**：我们可以初始化一个比较长的数组，只用前面一部分，这样在插入数据时，丢失的末尾元素都是我们不关心的，但这样做同时也会造成内存空间的浪费。
+- **内存浪费**：我们可以初始化一个比较长的数组，只用前面一部分，这样在插入数据时，丢失的末尾元素都是“无意义”的，但这样做也会造成部分内存空间的浪费。

-## 数组常用操作
+### 遍历数组

-**数组遍历**。以下介绍两种常用的遍历方法。
+在大多数编程语言中，我们既可以通过索引遍历数组，也可以直接遍历获取数组中的每个元素。

 === "Java"

@@ -509,7 +441,11 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
    [class]{}-[func]{traverse}
    ```

-**数组查找**。通过遍历数组，查找数组内的指定元素，并输出对应索引。
+### 查找元素
+
+在数组中查找指定元素需要遍历数组，每轮判断元素值是否匹配，若匹配则输出对应索引。
+
+因为数组是线性数据结构，所以上述查找操作被称为「线性查找」。

 === "Java"

@@ -583,12 +519,104 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
    [class]{}-[func]{find}
    ```

+### 扩容数组
+
+在复杂的系统环境中，程序难以保证数组之后的内存空间是可用的，从而无法安全地扩展数组容量。因此在大多数编程语言中，**数组的长度是不可变的**。
+
+如果我们希望扩容数组，则需重新建立一个更大的数组，然后把原数组元素依次拷贝到新数组。这是一个 $O(n)$ 的操作，在数组很大的情况下是非常耗时的。
+
+=== "Java"
+
+    ```java title="array.java"
+    [class]{array}-[func]{extend}
+    ```
+
+=== "C++"
+
+    ```cpp title="array.cpp"
+    [class]{}-[func]{extend}
+    ```
+
+=== "Python"
+
+    ```python title="array.py"
+    [class]{}-[func]{extend}
+    ```
+
+=== "Go"
+
+    ```go title="array.go"
+    [class]{}-[func]{extend}
+    ```
+
+=== "JS"
+
+    ```javascript title="array.js"
+    [class]{}-[func]{extend}
+    ```
+
+=== "TS"
+
+    ```typescript title="array.ts"
+    [class]{}-[func]{extend}
+    ```
+
+=== "C"
+
+    ```c title="array.c"
+    [class]{}-[func]{extend}
+    ```
+
+=== "C#"
+
+    ```csharp title="array.cs"
+    [class]{array}-[func]{extend}
+    ```
+
+=== "Swift"
+
+    ```swift title="array.swift"
+    [class]{}-[func]{extend}
+    ```
+
+=== "Zig"
+
+    ```zig title="array.zig"
+    [class]{}-[func]{extend}
+    ```
+
+=== "Dart"
+
+    ```dart title="array.dart"
+    [class]{}-[func]{extend}
+    ```
+
+=== "Rust"
+
+    ```rust title="array.rs"
+    [class]{}-[func]{extend}
+    ```
+
+## 数组优点与局限性
+
+数组存储在连续的内存空间内，且元素类型相同。这包含丰富的先验信息，系统可以利用这些信息来优化操作和运行效率，包括：
+
+- **空间效率高**: 数组为数据分配了连续的内存块，无需额外的结构开销。
+- **支持随机访问**: 数组允许在 $O(1)$ 时间内访问任何元素。
+- **缓存局部性**: 当访问数组元素时，计算机不仅会加载它，还会缓存其周围的其他数据，从而借助高速缓存来提升后续操作的执行速度。
+
+连续空间存储是一把双刃剑，它导致的缺点有：
+
+- **插入与删除效率低**:当数组中元素较多时，插入与删除操作需要移动大量的元素。
+- **长度不可变**: 数组在初始化后长度就固定了，扩容数组需要将所有数据复制到新数组，开销很大。
+- **空间浪费**: 如果数组分配的大小超过了实际所需，那么多余的空间就被浪费了。
+
 ## 数组典型应用

-数组是最基础的数据结构，在各类数据结构和算法中都有广泛应用。
+数组是一种基础且常见的数据结构，既频繁应用在各类算法之中，也可用于实现各种复杂数据结构，主要包括：

 - **随机访问**：如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。
- **排序和搜索**：数组是排序和搜索算法最常用的数据结构。例如，快速排序、归并排序、二分查找等都需要在数组上进行。
+- **排序和搜索**：数组是排序和搜索算法最常用的数据结构。快速排序、归并排序、二分查找等都主要在数组上进行。
 - **查找表**：当我们需要快速查找一个元素或者需要查找一个元素的对应关系时，可以使用数组作为查找表。假如我们想要实现字符到 ASCII 码的映射，则可以将字符的 ASCII 码值作为索引，对应的元素存放在数组中的对应位置。
 - **机器学习**：神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。
 - **数据结构实现**：数组可以用于实现栈、队列、哈希表、堆、图等数据结构。例如，图的邻接矩阵表示实际上是一个二维数组。