build

chapter_searching/binary_search.md

@@ -305,6 +305,30 @@ comments: true
     }
     ```
 
+=== "Rust"
+
+    ```rust title="binary_search.rs"
+    /* 二分查找（双闭区间） */
+    fn binary_search(nums: &[i32], target: i32) -> i32 {
+        // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        let mut i = 0;
+        let mut j = nums.len() - 1;
+        // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+        while i <= j {
+            let 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 as i32;
+            }                       
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
 时间复杂度为 $O(\log n)$ 。每轮缩小一半区间，因此二分循环次数为 $\log_2 n$ 。
 
 空间复杂度为 $O(1)$  。指针 `i` , `j` 使用常数大小空间。
@@ -572,6 +596,30 @@ comments: true
     }
     ```
 
+=== "Rust"
+
+    ```rust title="binary_search.rs"
+    /* 二分查找（左闭右开） */
+    fn binary_search_lcro(nums: &[i32], target: i32) -> i32 {
+        // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        let mut i = 0;
+        let mut j = nums.len();
+        // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while i < j {
+            let 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 - 1;
+            } else {                      // 找到目标元素，返回其索引
+                return m as i32;
+            }                       
+        }
+        // 未找到目标元素，返回 -1
+        return -1;
+    }
+    ```
+
 如下图所示，在两种区间表示下，二分查找算法的初始化、循环条件和缩小区间操作皆有所不同。
 
 在“双闭区间”表示法中，由于左右边界都被定义为闭区间，因此指针 $i$ 和 $j$ 缩小区间操作也是对称的。这样更不容易出错。因此，**我们通常采用“双闭区间”的写法**。

chapter_searching/binary_search_edge.md

@@ -288,6 +288,30 @@ comments: true
     }
     ```
 
+=== "Rust"
+
+    ```rust title="binary_search_edge.rs"
+    /* 二分查找最左一个元素 */
+    fn binary_search_left_edge(nums: &[i32], target: i32) -> i32 {
+        let mut i = 0;
+        let mut j = nums.len() as i32 - 1; // 初始化双闭区间 [0, n-1]
+        while i <= j {
+            let m = i + (j - i) / 2; // 计算中点索引 m
+            if nums[m as usize] < target {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if nums[m as usize] > target {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
+            }
+        }
+        if i == nums.len() as i32 || nums[i as usize] != target {
+            return -1; // 未找到目标元素，返回 -1
+        }
+        i
+    }
+    ```
+
 ## 10.2.3. &nbsp; 查找右边界
 
 类似地，我们也可以二分查找最右边的 `target` 。当 `nums[m] == target` 时，说明大于 `target` 的元素在区间 $[m + 1, j]$ 中，因此执行 `i = m + 1` ，**使得指针 $i$ 向大于 `target` 的元素靠近**。
@@ -524,6 +548,30 @@ comments: true
     }
     ```
 
+=== "Rust"
+
+    ```rust title="binary_search_edge.rs"
+    /* 二分查找最右一个元素 */
+    fn binary_search_right_edge(nums: &[i32], target: i32) -> i32 {
+        let mut i = 0;
+        let mut j = nums.len() as i32 - 1; // 初始化双闭区间 [0, n-1]
+        while i <= j {
+            let m = i + (j - i) / 2; // 计算中点索引 m
+            if nums[m as usize] < target {
+                i = m + 1; // target 在区间 [m+1, j] 中
+            } else if nums[m as usize] > target {
+                j = m - 1; // target 在区间 [i, m-1] 中
+            } else {
+                i = m + 1; // 首个大于 target 的元素在区间 [m+1, j] 中
+            }
+        }
+        if j < 0 || nums[j as usize] != target {
+            return -1; // 未找到目标元素，返回 -1
+        }
+        j
+    }
+    ```
+
 观察下图，搜索最右边元素时指针 $j$ 的作用与搜索最左边元素时指针 $i$ 的作用一致，反之亦然。也就是说，**搜索最左边元素和最右边元素的实现是镜像对称的**。
 
 ![查找最左边和最右边元素的对称性](binary_search_edge.assets/binary_search_left_right_edge.png)

chapter_searching/replace_linear_by_hashing.md

@@ -208,6 +208,24 @@ comments: true
     }
     ```
 
+=== "Rust"
+
+    ```rust title="two_sum.rs"
+    /* 方法一：暴力枚举 */
+    pub fn two_sum_brute_force(nums: &Vec<i32>, target: i32) -> Option<Vec<i32>> {
+        let size = nums.len();
+        // 两层循环，时间复杂度 O(n^2)
+        for i in 0..size - 1 {
+            for j in i + 1..size {
+                if nums[i] + nums[j] == target {
+                    return Some(vec![i as i32, j as i32]);
+                }
+            }
+        }
+        None
+    }
+    ```
+
 此方法的时间复杂度为 $O(n^2)$ ，空间复杂度为 $O(1)$ ，在大数据量下非常耗时。
 
 ## 10.3.2. &nbsp; 哈希查找：以空间换时间
@@ -462,6 +480,24 @@ comments: true
     }
     ```
 
+=== "Rust"
+
+    ```rust title="two_sum.rs"
+    /* 方法二：辅助哈希表 */
+    pub fn two_sum_hash_table(nums: &Vec<i32>, target: i32) -> Option<Vec<i32>> {
+        // 辅助哈希表，空间复杂度 O(n)
+        let mut dic = HashMap::new();
+        // 单层循环，时间复杂度 O(n)
+        for (i, num) in nums.iter().enumerate() {
+            match dic.get(&(target - num)) {
+                Some(v) => return Some(vec![*v as i32, i as i32]),
+                None => dic.insert(num, i as i32)
+            };
+        }
+        None
+    }
+    ```
+
 此方法通过哈希查找将时间复杂度从 $O(n^2)$ 降低至 $O(n)$ ，大幅提升运行效率。
 
 由于需要维护一个额外的哈希表，因此空间复杂度为 $O(n)$ 。**尽管如此，该方法的整体时空效率更为均衡，因此它是本题的最优解法**。