build

docs/chapter_array_and_linkedlist/array.md

@@ -637,13 +637,14 @@ comments: true
         count = 0
         # 通过索引遍历数组
         for i in range(len(nums)):
-            count += 1
-        # 直接遍历数组
+            count += nums[i]
+        # 直接遍历数组元素
         for num in nums:
-            count += 1
+            count += num
         # 同时遍历数据索引和元素
         for i, num in enumerate(nums):
-            count += 1
+            count += nums[i]
+            count += num
     ```
 
 === "C++"
@@ -654,7 +655,7 @@ comments: true
         int count = 0;
         // 通过索引遍历数组
         for (int i = 0; i < size; i++) {
-            count++;
+            count += nums[i];
         }
     }
     ```
@@ -667,11 +668,11 @@ comments: true
         int count = 0;
         // 通过索引遍历数组
         for (int i = 0; i < nums.length; i++) {
-            count++;
+            count += nums[i];
         }
-        // 直接遍历数组
+        // 直接遍历数组元素
         for (int num : nums) {
-            count++;
+            count += num;
         }
     }
     ```
@@ -684,11 +685,11 @@ comments: true
         int count = 0;
         // 通过索引遍历数组
         for (int i = 0; i < nums.Length; i++) {
-            count++;
+            count += nums[i];
         }
-        // 直接遍历数组
+        // 直接遍历数组元素
         foreach (int num in nums) {
-            count++;
+            count += num;
         }
     }
     ```
@@ -701,12 +702,17 @@ comments: true
         count := 0
         // 通过索引遍历数组
         for i := 0; i < len(nums); i++ {
-            count++
+            count += nums[i]
         }
         count = 0
-        // 直接遍历数组
-        for range nums {
-            count++
+        // 直接遍历数组元素
+        for _, num := range nums {
+            count += num
+        }
+        // 同时遍历数据索引和元素
+        for i, num := range nums {
+            count += nums[i]
+            count += num
         }
     }
     ```
@@ -718,12 +724,12 @@ comments: true
     func traverse(nums: [Int]) {
         var count = 0
         // 通过索引遍历数组
-        for _ in nums.indices {
-            count += 1
+        for i in nums.indices {
+            count += nums[i]
         }
-        // 直接遍历数组
-        for _ in nums {
-            count += 1
+        // 直接遍历数组元素
+        for num in nums {
+            count += num
         }
     }
     ```
@@ -736,11 +742,11 @@ comments: true
         let count = 0;
         // 通过索引遍历数组
         for (let i = 0; i < nums.length; i++) {
-            count++;
+            count += nums[i];
         }
-        // 直接遍历数组
+        // 直接遍历数组元素
         for (const num of nums) {
-            count += 1;
+            count += num;
         }
     }
     ```
@@ -753,11 +759,11 @@ comments: true
         let count = 0;
         // 通过索引遍历数组
         for (let i = 0; i < nums.length; i++) {
-            count++;
+            count += nums[i];
         }
-        // 直接遍历数组
+        // 直接遍历数组元素
         for (const num of nums) {
-            count += 1;
+            count += num;
         }
     }
     ```
@@ -770,15 +776,15 @@ comments: true
       var count = 0;
       // 通过索引遍历数组
       for (var i = 0; i < nums.length; i++) {
-        count++;
+        count += nums[i];
       }
-      // 直接遍历数组
+      // 直接遍历数组元素
       for (var num in nums) {
-        count++;
+        count += nums[i];
       }
       // 通过 forEach 方法遍历数组
       nums.forEach((element) {
-        count++;
+        count += element;
       });
     }
     ```
@@ -790,12 +796,12 @@ comments: true
     fn traverse(nums: &[i32]) {
         let mut _count = 0;
         // 通过索引遍历数组
-        for _ in 0..nums.len() {
-            _count += 1;
+        for i in 0..nums.len() {
+            _count += nums[i];
         }
-        // 直接遍历数组
-        for _ in nums {
-            _count += 1;
+        // 直接遍历数组元素
+        for num in nums {
+            _count += num;
         }
     }
     ```
@@ -808,7 +814,7 @@ comments: true
         int count = 0;
         // 通过索引遍历数组
         for (int i = 0; i < size; i++) {
-            count++;
+            count += nums[i];
         }
     }
     ```
@@ -822,12 +828,12 @@ comments: true
         // 通过索引遍历数组
         var i: i32 = 0;
         while (i < nums.len) : (i += 1) {
-            count += 1;
+            count += nums[i];
         }
         count = 0;
-        // 直接遍历数组
-        for (nums) |_| {
-            count += 1;
+        // 直接遍历数组元素
+        for (nums) |num| {
+            count += num;
         }
     }
     ```

docs/chapter_array_and_linkedlist/list.md

@@ -498,12 +498,11 @@ comments: true
     # 通过索引遍历列表
     count = 0
     for i in range(len(nums)):
-        count += 1
+        count += nums[i]
 
     # 直接遍历列表元素
-    count = 0
     for num in nums:
-        count += 1
+        count += num
     ```
 
 === "C++"
@@ -512,13 +511,13 @@ comments: true
     /* 通过索引遍历列表 */
     int count = 0;
     for (int i = 0; i < nums.size(); i++) {
-        count++;
+        count += nums[i];
     }
 
     /* 直接遍历列表元素 */
     count = 0;
     for (int num : nums) {
-        count++;
+        count += num;
     }
     ```
 
@@ -528,13 +527,12 @@ comments: true
     /* 通过索引遍历列表 */
     int count = 0;
     for (int i = 0; i < nums.size(); i++) {
-        count++;
+        count += nums.get(i);
     }
 
     /* 直接遍历列表元素 */
-    count = 0;
     for (int num : nums) {
-        count++;
+        count += num;
     }
     ```
 
@@ -544,13 +542,13 @@ comments: true
     /* 通过索引遍历列表 */
     int count = 0;
     for (int i = 0; i < nums.Count; i++) {
-        count++;
+        count += nums[i];
     }
 
     /* 直接遍历列表元素 */
     count = 0;
     foreach (int num in nums) {
-        count++;
+        count += num;
     }
     ```
 
@@ -560,13 +558,13 @@ comments: true
     /* 通过索引遍历列表 */
     count := 0
     for i := 0; i < len(nums); i++ {
-        count++
+        count += nums[i]
     }
 
     /* 直接遍历列表元素 */
     count = 0
-    for range nums {
-        count++
+    for _, num := range nums {
+        count += num
     }
     ```
 
@@ -575,14 +573,14 @@ comments: true
     ```swift title="list.swift"
     /* 通过索引遍历列表 */
     var count = 0
-    for _ in nums.indices {
-        count += 1
+    for i in nums.indices {
+        count += nums[i]
     }
 
     /* 直接遍历列表元素 */
     count = 0
-    for _ in nums {
-        count += 1
+    for num in nums {
+        count += num
     }
     ```
 
@@ -592,13 +590,13 @@ comments: true
     /* 通过索引遍历列表 */
     let count = 0;
     for (let i = 0; i < nums.length; i++) {
-        count++;
+        count += nums[i];
     }
 
     /* 直接遍历列表元素 */
     count = 0;
     for (const num of nums) {
-        count++;
+        count += num;
     }
     ```
 
@@ -608,13 +606,13 @@ comments: true
     /* 通过索引遍历列表 */
     let count = 0;
     for (let i = 0; i < nums.length; i++) {
-        count++;
+        count += nums[i];
     }
 
     /* 直接遍历列表元素 */
     count = 0;
     for (const num of nums) {
-        count++;
+        count += num;
     }
     ```
 
@@ -623,30 +621,30 @@ comments: true
     ```dart title="list.dart"
     /* 通过索引遍历列表 */
     int count = 0;
-    for (int i = 0; i < nums.length; i++) {
-        count++;
+    for (var i = 0; i < nums.length; i++) {
+        count += nums[i];
     }
-
+    
     /* 直接遍历列表元素 */
     count = 0;
-    for (int num in nums) {
-        count++;
+    for (var num in nums) {
+        count += num;
     }
     ```
 
 === "Rust"
 
     ```rust title="list.rs"
-    /* 通过索引遍历列表 */
-    let mut count = 0;
-    for (index, value) in nums.iter().enumerate() {
-        count += 1;
+    // 通过索引遍历列表
+    let mut _count = 0;
+    for i in 0..nums.len() {
+        _count += nums[i];
     }
 
-    /* 直接遍历列表元素 */
-    let mut count = 0;
-    for value in nums.iter() {
-        count += 1;
+    // 直接遍历列表元素
+    _count = 0;
+    for num in &nums {
+        _count += num;
     }
     ```
 
@@ -663,13 +661,13 @@ comments: true
     var count: i32 = 0;
     var i: i32 = 0;
     while (i < nums.items.len) : (i += 1) {
-        count += 1;
+        count += nums[i];
     }
 
     // 直接遍历列表元素
     count = 0;
-    for (nums.items) |_| {
-        count += 1;
+    for (nums.items) |num| {
+        count += num;
     }
     ```
 

docs/chapter_array_and_linkedlist/summary.md

@@ -37,7 +37,7 @@ comments: true
 
     不修改 `P.next` 也可以。从该链表的角度看，从头节点遍历到尾节点已经遇不到 `P` 了。这意味着节点 `P` 已经从链表中删除了，此时节点 `P` 指向哪里都不会对这条链表产生影响了。
 
-    从垃圾回收的角度看，对于 Java、Python、Go 等拥有自动垃圾回收的语言来说，节点 `P` 是否被回收取决于是否有仍存在指向它的引用，而不是 `P.next` 的值。在 C 和 C++ 等语言中，我们需要手动释放节点内存。
+    从垃圾回收的角度看，对于 Java、Python、Go 等拥有自动垃圾回收的语言来说，节点 `P` 是否被回收取决于是否仍存在指向它的引用，而不是 `P.next` 的值。在 C 和 C++ 等语言中，我们需要手动释放节点内存。
 
 !!! question "在链表中插入和删除操作的时间复杂度是 $O(1)$ 。但是增删之前都需要 $O(n)$ 查找元素，那为什么时间复杂度不是 $O(n)$ 呢？"