build

chapter_array_and_linkedlist/array.md

@@ -101,7 +101,9 @@ comments: true
 === "Dart"
 
     ```dart title="array.dart"
-
+    /* 初始化数组 */
+    List<int> arr = List.filled(5, 0); // [0, 0, 0, 0, 0]
+    List<int> nums = [1, 3, 2, 5, 4];
     ```
 
 ## 4.1.1. &nbsp; 数组优点
@@ -258,9 +260,9 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 === "Dart"
 
     ```dart title="array.dart"
-    /* 随机返回一个 数组元素 */
+    /* 随机返回一个数组元素 */
     int randomAccess(List nums) {
-      // 在区间[0,size) 中随机抽取一个数字
+      // 在区间 [0, nums.length) 中随机抽取一个数字
       int randomIndex = Random().nextInt(nums.length);
       // 获取并返回随机元素
       int randomNum = nums[randomIndex];
@@ -444,9 +446,8 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     ```dart title="array.dart"
     /* 扩展数组长度 */
     List extend(List nums, int enlarge) {
-      // 初始化一个扩展长度后的数组，元素初始值为0
+      // 初始化一个扩展长度后的数组
       List<int> res = List.filled(nums.length + enlarge, 0);
-
       // 将原数组中的所有元素复制到新数组
       for (var i = 0; i < nums.length; i++) {
         res[i] = nums[i];
@@ -606,7 +607,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     ```dart title="array.dart"
     /* 在数组的索引 index 处插入元素 num */
     void insert(List nums, int num, int index) {
-      // 把索引index以及之后的所有元素向后移动一位
+      // 把索引 index 以及之后的所有元素向后移动一位
       for (var i = nums.length - 1; i > index; i--) {
         nums[i] = nums[i - 1];
       }
@@ -747,6 +748,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     ```dart title="array.dart"
     /* 删除索引 index 处元素 */
     void remove(List nums, int index) {
+      // 把索引 index 之后的所有元素向前移动一位
       for (var i = index; i < nums.length - 1; i++) {
         nums[i] = nums[i + 1];
       }
@@ -942,7 +944,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
       for (var num in nums) {
         count++;
       }
-      // 通过forEach方法遍历数组
+      // 通过 forEach 方法遍历数组
       nums.forEach((element) {
         count++;
       });

chapter_array_and_linkedlist/linked_list.md

@@ -162,7 +162,12 @@ comments: true
 === "Dart"
 
     ```dart title=""
-
+    /* 链表节点类 */
+    class ListNode {
+      int val; // 节点值
+      ListNode? next; // 指向下一节点的指针（引用）
+      ListNode(this.val, [this.next]); // 构造函数
+    }
     ```
 
 !!! question "尾节点指向什么？"
@@ -348,7 +353,18 @@ comments: true
 === "Dart"
 
     ```dart title="linked_list.dart"
-
+    /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */\
+    // 初始化各个节点
+    ListNode n0 = ListNode(1);
+    ListNode n1 = ListNode(3);
+    ListNode n2 = ListNode(2);
+    ListNode n3 = ListNode(5);
+    ListNode n4 = ListNode(4);
+    // 构建引用指向
+    n0.next = n1;
+    n1.next = n2;
+    n2.next = n3;
+    n3.next = n4;
     ```
 
 ## 4.2.1.   链表优点
@@ -637,6 +653,7 @@ comments: true
     /* 删除链表的节点 n0 之后的首个节点 */
     void remove(ListNode n0) {
       if (n0.next == null) return;
+      // n0 -> P -> n1
       ListNode P = n0.next!;
       ListNode? n1 = P.next;
       n0.next = n1;
@@ -1159,7 +1176,13 @@ comments: true
 === "Dart"
 
     ```dart title=""
-
+    /* 双向链表节点类 */
+    class ListNode {
+        int val;        // 节点值
+        ListNode next;  // 指向后继节点的指针（引用）
+        ListNode prev;  // 指向前驱节点的指针（引用）
+        ListNode(this.val, [this.next, this.prev]);  // 构造函数
+    }
     ```
 
 ![常见链表种类](linked_list.assets/linkedlist_common_types.png)

chapter_array_and_linkedlist/list.md

@@ -113,7 +113,11 @@ comments: true
 === "Dart"
 
     ```dart title="list.dart"
-
+    /* 初始化列表 */
+    // 无初始值
+    List<int> list1 = [];
+    // 有初始值
+    List<int> list = [1, 3, 2, 5, 4];
     ```
 
 **访问与更新元素**。由于列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问和更新元素，效率很高。
@@ -217,7 +221,11 @@ comments: true
 === "Dart"
 
     ```dart title="list.dart"
+    /* 访问元素 */
+    int num = list[1];  // 访问索引 1 处的元素
 
+    /* 更新元素 */
+    list[1] = 0;  // 将索引 1 处的元素更新为 0
     ```
 
 **在列表中添加、插入、删除元素**。相较于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但插入和删除元素的效率仍与数组相同，时间复杂度为 $O(N)$ 。
@@ -411,7 +419,21 @@ comments: true
 === "Dart"
 
     ```dart title="list.dart"
+    /* 清空列表 */
+    list.clear();
 
+    /* 尾部添加元素 */
+    list.add(1);
+    list.add(3);
+    list.add(2);
+    list.add(5);
+    list.add(4);
+
+    /* 中间插入元素 */
+    list.insert(3, 6); // 在索引 3 处插入数字 6
+
+    /* 删除元素 */
+    list.removeAt(3); // 删除索引 3 处的元素
     ```
 
 **遍历列表**。与数组一样，列表可以根据索引遍历，也可以直接遍历各元素。
@@ -570,7 +592,17 @@ comments: true
 === "Dart"
 
     ```dart title="list.dart"
+    /* 通过索引遍历列表 */
+    int count = 0;
+    for (int i = 0; i < list.length; i++) {
+        count++;
+    }
 
+    /* 直接遍历列表元素 */
+    count = 0;
+    for (int n in list) {
+        count++;
+    }
     ```
 
 **拼接两个列表**。给定一个新列表 `list1` ，我们可以将该列表拼接到原列表的尾部。
@@ -659,7 +691,9 @@ comments: true
 === "Dart"
 
     ```dart title="list.dart"
-
+    /* 拼接两个列表 */
+    List<int> list1 = [6, 8, 7, 10, 9];
+    list.addAll(list1);  // 将列表 list1 拼接到 list 之后
     ```
 
 **排序列表**。排序也是常用的方法之一。完成列表排序后，我们便可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法。
@@ -736,7 +770,8 @@ comments: true
 === "Dart"
 
     ```dart title="list.dart"
-
+    /* 排序列表 */
+    list.sort(); // 排序后，列表元素从小到大排列
     ```
 
 ## 4.3.2. &nbsp; 列表实现 *