build

chapter_searching/binary_search.md

@@ -279,6 +279,32 @@ comments: true
     }
     ```
 
+=== "Dart"
+
+    ```dart title="binary_search.dart"
+    /* 二分查找（双闭区间） */
+    int binarySearch(List<int> nums, int target) {
+      // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+      int i = 0, j = nums.length - 1;
+      // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+      while (i <= j) {
+        int m = i + (j - i) ~/ 2; // 计算中点索引 m
+        if (nums[m] < target) {
+          // 此情况说明 target 在区间 [m+1, j] 中
+          i = m + 1;
+        } else if (nums[m] > target) {
+          // 此情况说明 target 在区间 [i, m-1] 中
+          j = m - 1;
+        } else {
+          // 找到目标元素，返回其索引
+          return m;
+        }
+      }
+      // 未找到目标元素，返回 -1
+      return -1;
+    }
+    ```
+
 时间复杂度为 $O(\log n)$ 。每轮缩小一半区间，因此二分循环次数为 $\log_2 n$ 。
 
 空间复杂度为 $O(1)$  。指针 `i` , `j` 使用常数大小空间。
@@ -520,6 +546,32 @@ comments: true
     }
     ```
 
+=== "Dart"
+
+    ```dart title="binary_search.dart"
+    /* 二分查找（左闭右开区间） */
+    int binarySearchLCRO(List<int> nums, int target) {
+      // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+      int i = 0, j = nums.length;
+      // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+      while (i < j) {
+        int m = i + (j - i) ~/ 2; // 计算中点索引 m
+        if (nums[m] < target) {
+          // 此情况说明 target 在区间 [m+1, j) 中
+          i = m + 1;
+        } else if (nums[m] > target) {
+          // 此情况说明 target 在区间 [i, m) 中
+          j = m;
+        } else {
+          // 找到目标元素，返回其索引
+          return m;
+        }
+      }
+      // 未找到目标元素，返回 -1
+      return -1;
+    }
+    ```
+
 如下图所示，在两种区间表示下，二分查找算法的初始化、循环条件和缩小区间操作皆有所不同。
 
 在“双闭区间”表示法中，由于左右边界都被定义为闭区间，因此指针 $i$ 和 $j$ 缩小区间操作也是对称的。这样更不容易出错。因此，**我们通常采用“双闭区间”的写法**。

chapter_searching/binary_search_edge.md

@@ -218,6 +218,12 @@ comments: true
     [class]{}-[func]{binarySearchLeftEdge}
     ```
 
+=== "Dart"
+
+    ```dart title="binary_search_edge.dart"
+    [class]{}-[func]{binarySearchLeftEdge}
+    ```
+
 ## 10.2.3.   查找右边界
 
 类似地，我们也可以二分查找最右边的 `target` 。当 `nums[m] == target` 时，说明大于 `target` 的元素在区间 $[m + 1, j]$ 中，因此执行 `i = m + 1` ，**使得指针 $i$ 向大于 `target` 的元素靠近**。
@@ -384,6 +390,12 @@ comments: true
     [class]{}-[func]{binarySearchRightEdge}
     ```
 
+=== "Dart"
+
+    ```dart title="binary_search_edge.dart"
+    [class]{}-[func]{binarySearchRightEdge}
+    ```
+
 观察下图，搜索最右边元素时指针 $j$ 的作用与搜索最左边元素时指针 $i$ 的作用一致，反之亦然。也就是说，**搜索最左边元素和最右边元素的实现是镜像对称的**。
 
 ![查找最左边和最右边元素的对称性](binary_search_edge.assets/binary_search_left_right_edge.png)

chapter_searching/replace_linear_by_hashing.md

@@ -193,6 +193,21 @@ comments: true
     }
     ```
 
+=== "Dart"
+
+    ```dart title="two_sum.dart"
+    /* 方法一： 暴力枚举 */
+    List<int> twoSumBruteForce(List<int> nums, int target) {
+      int size = nums.length;
+      for (var i = 0; i < size - 1; i++) {
+        for (var j = i + 1; j < size; j++) {
+          if (nums[i] + nums[j] == target) return [i, j];
+        }
+      }
+      return [0];
+    }
+    ```
+
 此方法的时间复杂度为 $O(n^2)$ ，空间复杂度为 $O(1)$ ，在大数据量下非常耗时。
 
 ## 10.3.2. &nbsp; 哈希查找：以空间换时间
@@ -430,6 +445,23 @@ comments: true
     }
     ```
 
+=== "Dart"
+
+    ```dart title="two_sum.dart"
+    /* 方法二： 辅助哈希表 */
+    List<int> twoSumHashTable(List<int> nums, int target) {
+      int size = nums.length;
+      Map<int, int> dic = HashMap();
+      for (var i = 0; i < size; i++) {
+        if (dic.containsKey(target - nums[i])) {
+          return [dic[target - nums[i]]!, i];
+        }
+        dic.putIfAbsent(nums[i], () => i);
+      }
+      return [0];
+    }
+    ```
+
 此方法通过哈希查找将时间复杂度从 $O(n^2)$ 降低至 $O(n)$ ，大幅提升运行效率。
 
 由于需要维护一个额外的哈希表，因此空间复杂度为 $O(n)$ 。**尽管如此，该方法的整体时空效率更为均衡，因此它是本题的最优解法**。