Polish the chapter of array and linkedlist

2026-07-26 21:16:07 +00:00 · 2023-08-17 05:13:19 +08:00
parent 0858ab91c0
commit c310edb672
26 changed files with 287 additions and 236 deletions
@@ -1,20 +1,26 @@
 # 链表

-内存空间是所有程序的公共资源，排除已被占用的内存空间，空闲内存空间通常散落在内存各处。在上一节中，我们提到存储数组的内存空间必须是连续的，而当需要申请一个非常大的数组时，空闲内存中可能没有这么大的连续空间。与数组相比，链表更具灵活性，它可以被存储在非连续的内存空间中。
+内存空间是所有程序的公共资源，在一个复杂的系统运行环境下，空闲的内存空间可能散落在内存各处。我们知道，存储数组的内存空间必须是连续的，而当数组非常大时，内存可能无法提供如此大的连续空间。此时链表的灵活性优势就体现出来了。

-「链表 Linked List」是一种线性数据结构，其每个元素都是一个节点对象，各个节点之间通过指针连接，从当前节点通过指针可以访问到下一个节点。**由于指针记录了下个节点的内存地址，因此无需保证内存地址的连续性**，从而可以将各个节点分散存储在内存各处。
-
-链表中的「节点 Node」包含两项数据，一是节点「值 Value」，二是指向下一节点的「引用 Reference」，或称「指针 Pointer」。
+「链表 Linked List」是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。引用记录了下一个节点的内存地址，我们可以通过它从当前节点访问到下一个节点。这意味着链表的各个节点可以被分散存储在内存各处，它们的内存地址是无需连续的。

 ![链表定义与存储方式](linked_list.assets/linkedlist_definition.png)

+观察上图，链表中的每个「节点 Node」对象都包含两项数据：节点的“值”、指向下一节点的“引用”。
+
+- 链表的首个节点被称为“头节点”，最后一个节点被称为“尾节点”。
+- 尾节点指向的是“空”，它在 Java, C++, Python 中分别被记为 $\text{null}$ , $\text{nullptr}$ , $\text{None}$ 。
+- 在 C, C++, Go, Rust 等支持指针的语言中，上述的“引用”应被替换为“指针”。
+
+如以下代码所示，链表以节点对象 `ListNode` 为单位，每个节点除了包含值，还需额外保存下一节点的引用（指针）。因此在相同数据量下，**链表通常比数组占用更多的内存空间**。
+
 === "Java"

    ```java title=""
    /* 链表节点类 */
    class ListNode {
        int val;        // 节点值
-        ListNode next;  // 指向下一节点的指针（引用）
+        ListNode next;  // 指向下一节点的引用
        ListNode(int x) { val = x; }  // 构造函数
    }
    ```
@@ -25,7 +31,7 @@
    /* 链表节点结构体 */
    struct ListNode {
        int val;         // 节点值
-        ListNode *next;  // 指向下一节点的指针（引用）
+        ListNode *next;  // 指向下一节点的指针
        ListNode(int x) : val(x), next(nullptr) {}  // 构造函数
    };
    ```
@@ -37,7 +43,7 @@
        """链表节点类"""
        def __init__(self, val: int):
            self.val: int = val                  # 节点值
-            self.next: Optional[ListNode] = None # 指向下一节点的指针（引用）
+            self.next: Optional[ListNode] = None # 指向下一节点的引用
    ```

 === "Go"
@@ -46,7 +52,7 @@
    /* 链表节点结构体 */
    type ListNode struct {
        Val  int       // 节点值
-        Next *ListNode // 指向下一节点的指针（引用）
+        Next *ListNode // 指向下一节点的指针
    }

    // NewListNode 构造函数，创建一个新的链表
@@ -92,7 +98,7 @@
    /* 链表节点结构体 */
    struct ListNode {
        int val;               // 节点值
-        struct ListNode *next; // 指向下一节点的指针（引用）
+        struct ListNode *next; // 指向下一节点的指针
    };

    typedef struct ListNode ListNode;
@@ -124,7 +130,7 @@
    /* 链表节点类 */
    class ListNode {
        var val: Int // 节点值
-        var next: ListNode? // 指向下一节点的指针（引用）
+        var next: ListNode? // 指向下一节点的引用

        init(x: Int) { // 构造函数
            val = x
@@ -141,7 +147,7 @@
            const Self = @This();

            val: T = 0, // 节点值
-            next: ?*Self = null, // 指向下一节点的指针（引用）
+            next: ?*Self = null, // 指向下一节点的指针

            // 构造函数
            pub fn init(self: *Self, x: i32) void {
@@ -158,7 +164,7 @@
    /* 链表节点类 */
    class ListNode {
      int val; // 节点值
-      ListNode? next; // 指向下一节点的指针（引用）
+      ListNode? next; // 指向下一节点的引用
      ListNode(this.val, [this.next]); // 构造函数
    }
    ```
@@ -172,13 +178,15 @@
    #[derive(Debug)]
    struct ListNode {
        val: i32, // 节点值
-        next: Option<Rc<RefCell<ListNode>>>, // 指向下一节点的指针（引用）
+        next: Option<Rc<RefCell<ListNode>>>, // 指向下一节点的指针
    }
    ```

-我们将链表的首个节点称为「头节点」，最后一个节点称为「尾节点」。尾节点指向的是“空”，在 Java, C++, Python 中分别记为 $\text{null}$ , $\text{nullptr}$ , $\text{None}$ 。在不引起歧义的前提下，本书都使用 $\text{None}$ 来表示空。
+## 链表常用操作

-**链表初始化方法**。建立链表分为两步，第一步是初始化各个节点对象，第二步是构建引用指向关系。完成后，即可以从链表的头节点（即首个节点）出发，通过指针 `next` 依次访问所有节点。
+### 初始化链表
+
+建立链表分为两步，第一步是初始化各个节点对象，第二步是构建引用指向关系。初始化完成后，我们就可以从链表的头节点出发，通过引用指向 `next` 依次访问所有节点。

 === "Java"

@@ -385,11 +393,13 @@
    n3.borrow_mut().next = Some(n4.clone());
    ```

-在编程语言中，数组整体是一个变量，比如数组 `nums` 包含元素 `nums[0]` , `nums[1]` 等。而链表是由多个分散的节点对象组成，**我们通常将头节点当作链表的代称**，比如以上代码中的链表可被记做链表 `n0` 。
+数组整体是一个变量，比如数组 `nums` 包含元素 `nums[0]` , `nums[1]` 等，而链表是由多个独立的节点对象组成的。**我们通常将头节点当作链表的代称**，比如以上代码中的链表可被记做链表 `n0` 。

-## 链表优点
+### 插入节点

-**链表中插入与删除节点的操作效率高**。如果我们想在链表中间的两个节点 `A` , `B` 之间插入一个新节点 `P` ，我们只需要改变两个节点指针即可，时间复杂度为 $O(1)$ ；相比之下，数组的插入操作效率要低得多。
+**在链表中插入节点非常容易**。假设我们想在相邻的两个节点 `n0` , `n1` 之间插入一个新节点 `P` ，则只需要改变两个节点引用（指针）即可，时间复杂度为 $O(1)$ 。
+
+相比之下，在数组中插入元素的时间复杂度为 $O(n)$ ，在大数据量下的效率较低。

 ![链表插入节点](linked_list.assets/linkedlist_insert_node.png)

@@ -465,7 +475,11 @@
    [class]{}-[func]{insert}
    ```

-在链表中删除节点也非常方便，只需改变一个节点的指针即可。如下图所示，尽管在删除操作完成后，节点 `P` 仍然指向 `n1` ，但实际上 `P` 已经不再属于此链表，因为遍历此链表时无法访问到 `P` 。
+### 删除节点
+
+在链表中删除节点也非常简便，只需改变一个节点的引用（指针）即可。
+
+请注意，尽管在删除操作完成后节点 `P` 仍然指向 `n1` ，但实际上遍历此链表已经无法访问到 `P` ，这意味着 `P` 已经不再属于该链表了。

 ![链表删除节点](linked_list.assets/linkedlist_remove_node.png)

@@ -541,9 +555,9 @@
    [class]{}-[func]{remove}
    ```

-## 链表缺点
+### 访问节点

-**链表访问节点效率较低**。如上节所述，数组可以在 $O(1)$ 时间下访问任意元素。然而链表无法直接访问任意节点，因为程序需要从头节点出发，逐个向后遍历，直至找到目标节点。也就是说，如果想要访问链表中第 $i$ 个节点，则需要向后遍历 $i - 1$ 轮。
+**在链表访问节点的效率较低**。如上节所述，我们可以在 $O(1)$ 时间下访问数组中的任意元素。链表则不然，程序需要从头节点出发，逐个向后遍历，直至找到目标节点。也就是说，访问链表的第 $i$ 个节点需要循环 $i - 1$ 轮，时间复杂度为 $O(n)$ 。

 === "Java"

@@ -617,11 +631,9 @@
    [class]{}-[func]{access}
    ```

-**链表的内存占用较大**。链表以节点为单位，每个节点除了包含值，还需额外保存下一节点的引用（指针）。这意味着在相同数据量的情况下，链表比数组需要占用更多的内存空间。
+### 查找节点

-## 链表常用操作
-
-**遍历链表查找**。遍历链表，查找链表内值为 `target` 的节点，输出节点在链表中的索引。
+遍历链表，查找链表内值为 `target` 的节点，输出节点在链表中的索引。此过程也属于「线性查找」。

 === "Java"

@@ -695,13 +707,31 @@
    [class]{}-[func]{find}
    ```

+## 数组 VS 链表
+
+下表总结对比了数组和链表的各项特点与操作效率。由于它们采用两种相反的存储策略，因此各种性质和操作效率也呈现对立的特点。
+
+<div class="center-table" markdown>
+
+|            | 数组                     | 链表         |
+| ---------- | ------------------------ | ------------ |
+| 存储方式   | 连续内存空间             | 离散内存空间 |
+| 缓存局部性 | 友好                     | 不友好       |
+| 容量扩展   | 长度不可变               | 可灵活扩展   |
+| 内存效率   | 占用内存少、浪费部分空间 | 占用内存多   |
+| 访问元素   | $O(1)$                   | $O(n)$       |
+| 添加元素   | $O(n)$                   | $O(1)$       |
+| 删除元素   | $O(n)$                   | $O(1)$       |
+
+</div>
+
 ## 常见链表类型

-**单向链表**。即上述介绍的普通链表。单向链表的节点包含值和指向下一节点的指针（引用）两项数据。我们将首个节点称为头节点，将最后一个节点成为尾节点，尾节点指向空 $\text{None}$ 。
+**单向链表**。即上述介绍的普通链表。单向链表的节点包含值和指向下一节点的引用两项数据。我们将首个节点称为头节点，将最后一个节点成为尾节点，尾节点指向空 $\text{None}$ 。

 **环形链表**。如果我们令单向链表的尾节点指向头节点（即首尾相接），则得到一个环形链表。在环形链表中，任意节点都可以视作头节点。

-**双向链表**。与单向链表相比，双向链表记录了两个方向的指针（引用）。双向链表的节点定义同时包含指向后继节点（下一节点）和前驱节点（上一节点）的指针。相较于单向链表，双向链表更具灵活性，可以朝两个方向遍历链表，但相应地也需要占用更多的内存空间。
+**双向链表**。与单向链表相比，双向链表记录了两个方向的引用。双向链表的节点定义同时包含指向后继节点（下一个节点）和前驱节点（上一个节点）的引用（指针）。相较于单向链表，双向链表更具灵活性，可以朝两个方向遍历链表，但相应地也需要占用更多的内存空间。

 === "Java"

@@ -709,8 +739,8 @@
    /* 双向链表节点类 */
    class ListNode {
        int val;        // 节点值
-        ListNode next;  // 指向后继节点的指针（引用）
-        ListNode prev;  // 指向前驱节点的指针（引用）
+        ListNode next;  // 指向后继节点的引用
+        ListNode prev;  // 指向前驱节点的引用
        ListNode(int x) { val = x; }  // 构造函数
    }
    ```
@@ -721,8 +751,8 @@
    /* 双向链表节点结构体 */
    struct ListNode {
        int val;         // 节点值
-        ListNode *next;  // 指向后继节点的指针（引用）
-        ListNode *prev;  // 指向前驱节点的指针（引用）
+        ListNode *next;  // 指向后继节点的指针
+        ListNode *prev;  // 指向前驱节点的指针
        ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // 构造函数
    };
    ```
@@ -734,8 +764,8 @@
        """双向链表节点类"""
        def __init__(self, val: int):
            self.val: int = val                   # 节点值
-            self.next: Optional[ListNode] = None  # 指向后继节点的指针（引用）
-            self.prev: Optional[ListNode] = None  # 指向前驱节点的指针（引用）
+            self.next: Optional[ListNode] = None  # 指向后继节点的引用
+            self.prev: Optional[ListNode] = None  # 指向前驱节点的引用
    ```

 === "Go"
@@ -744,8 +774,8 @@
    /* 双向链表节点结构体 */
    type DoublyListNode struct {
        Val  int             // 节点值
-        Next *DoublyListNode // 指向后继节点的指针（引用）
-        Prev *DoublyListNode // 指向前驱节点的指针（引用）
+        Next *DoublyListNode // 指向后继节点的指针
+        Prev *DoublyListNode // 指向前驱节点的指针
    }

    // NewDoublyListNode 初始化
@@ -768,8 +798,8 @@
        prev;
        constructor(val, next, prev) {
            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;  // 指向前驱节点的引用
        }
    }
    ```
@@ -784,8 +814,8 @@
        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;  // 指向前驱节点的引用
        }
    }
    ```
@@ -796,8 +826,8 @@
    /* 双向链表节点结构体 */
    struct ListNode {
        int val;               // 节点值
-        struct ListNode *next; // 指向后继节点的指针（引用）
-        struct ListNode *prev; // 指向前驱节点的指针（引用）
+        struct ListNode *next; // 指向后继节点的指针
+        struct ListNode *prev; // 指向前驱节点的指针
    };

    typedef struct ListNode ListNode;
@@ -819,8 +849,8 @@
    /* 双向链表节点类 */
    class ListNode {
        int val;        // 节点值
-        ListNode next;  // 指向后继节点的指针（引用）
-        ListNode prev;  // 指向前驱节点的指针（引用）
+        ListNode next;  // 指向后继节点的引用
+        ListNode prev;  // 指向前驱节点的引用
        ListNode(int x) => val = x;  // 构造函数
    }
    ```
@@ -831,8 +861,8 @@
    /* 双向链表节点类 */
    class ListNode {
        var val: Int // 节点值
-        var next: ListNode? // 指向后继节点的指针（引用）
-        var prev: ListNode? // 指向前驱节点的指针（引用）
+        var next: ListNode? // 指向后继节点的引用
+        var prev: ListNode? // 指向前驱节点的引用

        init(x: Int) { // 构造函数
            val = x
@@ -849,8 +879,8 @@
            const Self = @This();

            val: T = 0, // 节点值
-            next: ?*Self = null, // 指向后继节点的指针（引用）
-            prev: ?*Self = null, // 指向前驱节点的指针（引用）
+            next: ?*Self = null, // 指向后继节点的指针
+            prev: ?*Self = null, // 指向前驱节点的指针

            // 构造函数
            pub fn init(self: *Self, x: i32) void {
@@ -867,10 +897,10 @@
    ```dart title=""
    /* 双向链表节点类 */
    class ListNode {
-      int val;        // 节点值
-      ListNode next;  // 指向后继节点的指针（引用）
-      ListNode prev;  // 指向前驱节点的指针（引用）
-      ListNode(this.val, [this.next, this.prev]);  // 构造函数
+        int val;        // 节点值
+        ListNode next;  // 指向后继节点的引用
+        ListNode prev;  // 指向前驱节点的引用
+        ListNode(this.val, [this.next, this.prev]);  // 构造函数
    }
    ```

@@ -884,8 +914,8 @@
    #[derive(Debug)]
    struct ListNode {
        val: i32, // 节点值
-        next: Option<Rc<RefCell<ListNode>>>, // 指向后继节点的指针（引用）
-        prev: Option<Rc<RefCell<ListNode>>>, // 指向前驱节点的指针（引用）
+        next: Option<Rc<RefCell<ListNode>>>, // 指向后继节点的指针
+        prev: Option<Rc<RefCell<ListNode>>>, // 指向前驱节点的指针
    }

    /* 构造函数 */
@@ -912,7 +942,7 @@

 双向链表常被用于需要快速查找前一个和下一个元素的场景。

- **高级数据结构**：比如在红黑树、B 树中，我们需要知道一个节点的父节点，这可以通过在节点中保存一个指向父节点的指针来实现，类似于双向链表。
+- **高级数据结构**：比如在红黑树、B 树中，我们需要访问节点的父节点，这可以通过在节点中保存一个指向父节点的引用来实现，类似于双向链表。
 - **浏览器历史**：在网页浏览器中，当用户点击前进或后退按钮时，浏览器需要知道用户访问过的前一个和后一个网页。双向链表的特性使得这种操作变得简单。
 - **LRU 算法**：在缓存淘汰算法（LRU）中，我们需要快速找到最近最少使用的数据，以及支持快速地添加和删除节点。这时候使用双向链表就非常合适。