zig : upgrade codes && rust : add codes for chapter_searching and chapter_dynamic_programming. (#591)

* zig : update zig codes

* rust : add codes for linear_search and hashing_search

* rust : add codes for linear_search and hashing_search

* rust : add codes for chapter_dynamic_programming

codes/rust/Cargo.toml

@@ -154,5 +154,45 @@ path = "chapter_tree/binary_tree_dfs.rs"
 name = "binary_tree"
 path = "chapter_tree/binary_tree.rs"
 
+# Run Command: cargo run --bin linear_search
+[[bin]]
+name = "linear_search"
+path = "chapter_searching/linear_search.rs"
+
+# Run Command: cargo run --bin hashing_search
+[[bin]]
+name = "hashing_search"
+path = "chapter_searching/hashing_search.rs"
+
+# Run Command: cargo run --bin climbing_stairs_dfs
+[[bin]]
+name = "climbing_stairs_dfs"
+path = "chapter_dynamic_programming/climbing_stairs_dfs.rs"
+
+# Run Command: cargo run --bin climbing_stairs_dfs_mem
+[[bin]]
+name = "climbing_stairs_dfs_mem"
+path = "chapter_dynamic_programming/climbing_stairs_dfs_mem.rs"
+
+# Run Command: cargo run --bin climbing_stairs_dp
+[[bin]]
+name = "climbing_stairs_dp"
+path = "chapter_dynamic_programming/climbing_stairs_dp.rs"
+
+# Run Command: cargo run --bin min_cost_climbing_stairs_dp
+[[bin]]
+name = "min_cost_climbing_stairs_dp"
+path = "chapter_dynamic_programming/min_cost_climbing_stairs_dp.rs"
+
+# Run Command: cargo run --bin climbing_stairs_constraint_dp
+[[bin]]
+name = "climbing_stairs_constraint_dp"
+path = "chapter_dynamic_programming/climbing_stairs_constraint_dp.rs"
+
+# Run Command: cargo run --bin climbing_stairs_backtrack
+[[bin]]
+name = "climbing_stairs_backtrack"
+path = "chapter_dynamic_programming/climbing_stairs_backtrack.rs"
+
 [dependencies]
 rand = "0.8.5"

codes/rust/chapter_dynamic_programming/climbing_stairs_backtrack.rs

@@ -0,0 +1,37 @@
+/*
+ * File: climbing_stairs_backtrack.rs
+ * Created Time: 2023-07-09
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+/* 回溯 */
+fn backtrack(choices: &[i32], state: i32, n: i32, res: &mut [i32]) {
+    // 当爬到第 n 阶时，方案数量加 1
+    if state == n { res[0] = res[0] + 1; }
+    // 遍历所有选择
+    for &choice in choices {
+        // 剪枝：不允许越过第 n 阶
+        if state + choice > n { break; }
+        // 尝试：做出选择，更新状态
+        backtrack(choices, state + choice, n, res);
+        // 回退
+    }
+}
+
+/* 爬楼梯：回溯 */
+fn climbing_stairs_backtrack(n: usize) -> i32 {
+    let choices = vec![ 1, 2 ]; // 可选择向上爬 1 或 2 阶
+    let state = 0; // 从第 0 阶开始爬
+    let mut res = Vec::new();
+    res.push(0); // 使用 res[0] 记录方案数量
+    backtrack(&choices, state, n as i32, &mut res);
+    res[0]
+}
+
+/* Driver Code */
+pub fn main() {
+    let n: usize = 9;
+
+    let res = climbing_stairs_backtrack(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+}

codes/rust/chapter_dynamic_programming/climbing_stairs_constraint_dp.rs

@@ -0,0 +1,31 @@
+/*
+ * File: climbing_stairs_constraint_dp.rs
+ * Created Time: 2023-07-09
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+/* 带约束爬楼梯：动态规划 */
+fn climbing_stairs_constraint_dp(n: usize) -> i32 {
+    if n == 1 || n == 2 { return n as i32 };
+    // 初始化 dp 表，用于存储子问题的解
+    let mut dp = vec![vec![-1; 3]; n + 1];
+    // 初始状态：预设最小子问题的解
+    dp[1][1] = 1;
+    dp[1][2] = 0;
+    dp[2][1] = 0;
+    dp[2][2] = 1;
+    // 状态转移：从较小子问题逐步求解较大子问题
+    for i in 3..=n {
+        dp[i][1] = dp[i - 1][2];
+        dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
+    }
+    dp[n][1] + dp[n][2]
+}
+
+/* Driver Code */
+pub fn main() {
+    let n: usize = 9;
+
+    let res = climbing_stairs_constraint_dp(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+}

codes/rust/chapter_dynamic_programming/climbing_stairs_dfs.rs

@@ -0,0 +1,27 @@
+/*
+ * File: climbing_stairs_dfs.rs
+ * Created Time: 2023-07-09
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+/* 搜索 */
+fn dfs(i: usize) -> i32 {
+    // 已知 dp[1] 和 dp[2] ，返回之
+    if i == 1 || i == 2 { return i as i32 };
+    // dp[i] = dp[i-1] + dp[i-2]
+    let count = dfs(i - 1) + dfs(i - 2);
+    count
+}
+
+/* 爬楼梯：搜索 */
+fn climbing_stairs_dfs(n: usize) -> i32 {
+    dfs(n) 
+}
+
+/* Driver Code */
+pub fn main() {
+    let n: usize = 9;
+
+    let res = climbing_stairs_dfs(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+}

codes/rust/chapter_dynamic_programming/climbing_stairs_dfs_mem.rs

@@ -0,0 +1,33 @@
+/*
+ * File: climbing_stairs_dfs_mem.rs
+ * Created Time: 2023-07-09
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+/* 记忆化搜索 */
+fn dfs(i: usize, mem: &mut [i32]) -> i32 {
+    // 已知 dp[1] 和 dp[2] ，返回之
+    if i == 1 || i == 2 { return i as i32};
+    // 若存在记录 dp[i] ，则直接返回之
+    if mem[i] != -1 { return mem[i] };
+    // dp[i] = dp[i-1] + dp[i-2]
+    let count = dfs(i - 1, mem) + dfs(i - 2, mem);
+    // 记录 dp[i]
+    mem[i] = count;
+    count
+}
+
+/* 爬楼梯：记忆化搜索 */
+fn climbing_stairs_dfs_mem(n: usize) -> i32 {
+    // mem[i] 记录爬到第 i 阶的方案总数，-1 代表无记录
+    let mut mem = vec![-1; n + 1];
+    dfs(n, &mut mem)
+}
+
+/* Driver Code */
+pub fn main() {
+    let n: usize = 9;
+
+    let res = climbing_stairs_dfs_mem(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+}

codes/rust/chapter_dynamic_programming/climbing_stairs_dp.rs

@@ -0,0 +1,44 @@
+/*
+ * File: climbing_stairs_dp.rs
+ * Created Time: 2023-07-09
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+/* 爬楼梯：动态规划 */
+fn climbing_stairs_dp(n: usize) -> i32 {
+    // 已知 dp[1] 和 dp[2] ，返回之
+    if n == 1 || n == 2 { return n as i32 };
+    // 初始化 dp 表，用于存储子问题的解
+    let mut dp = vec![-1; n + 1];
+    // 初始状态：预设最小子问题的解
+    dp[1] = 1;
+    dp[2] = 2;
+    // 状态转移：从较小子问题逐步求解较大子问题
+    for i in 3..=n {
+        dp[i] = dp[i - 1] + dp[i - 2];
+    }
+    dp[n]
+}
+
+/* 爬楼梯：状态压缩后的动态规划 */
+fn climbing_stairs_dp_comp(n: usize) -> i32 {
+    if n == 1 || n == 2 { return n as i32 };
+    let (mut a, mut b) = (1, 2);
+    for _ in 3..=n {
+        let tmp = b;
+        b = a + b;
+        a = tmp;
+    }
+    b
+}
+
+/* Driver Code */
+pub fn main() {
+    let n: usize = 9;
+
+    let res = climbing_stairs_dp(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+
+    let res = climbing_stairs_dp_comp(n);
+    println!("爬 {n} 阶楼梯共有 {res} 种方案");
+}

codes/rust/chapter_dynamic_programming/min_cost_climbing_stairs_dp.rs

@@ -0,0 +1,48 @@
+/*
+ * File: min_cost_climbing_stairs_dp.rs
+ * Created Time: 2023-07-09
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+ use std::cmp;
+
+/* 爬楼梯最小代价：动态规划 */
+fn min_cost_climbing_stairs_dp(cost: &[i32]) -> i32 {
+    let n = cost.len() - 1;
+    if n == 1 || n == 2 { return cost[n] };
+    // 初始化 dp 表，用于存储子问题的解
+    let mut dp = vec![-1; n + 1];
+    // 初始状态：预设最小子问题的解
+    dp[1] = cost[1];
+    dp[2] = cost[2];
+    // 状态转移：从较小子问题逐步求解较大子问题
+    for i in 3..=n {
+        dp[i] = cmp::min(dp[i - 1], dp[i - 2]) + cost[i];
+    }
+    dp[n]
+}
+
+/* 爬楼梯最小代价：状态压缩后的动态规划 */
+fn min_cost_climbing_stairs_dp_comp(cost: &[i32]) -> i32 {
+    let n = cost.len() - 1;
+    if n == 1 || n == 2 { return cost[n] };
+    let (mut a, mut b) = (cost[1], cost[2]);
+    for i in 3..=n {
+        let tmp = b;
+        b = cmp::min(a, tmp) + cost[i];
+        a = tmp;
+    }
+    b
+}
+
+/* Driver Code */
+pub fn main() {
+    let cost = [ 0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1 ];
+    println!("输入楼梯的代价列表为 {:?}", &cost);
+
+    let res = min_cost_climbing_stairs_dp(&cost);
+    println!("爬完楼梯的最低代价为 {res}");
+
+    let res = min_cost_climbing_stairs_dp_comp(&cost);
+    println!("爬完楼梯的最低代价为 {res}");
+}

codes/rust/chapter_searching/hashing_search.rs

@@ -0,0 +1,49 @@
+/*
+ * File: hashing_search.rs
+ * Created Time: 2023-07-09
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+ include!("../include/include.rs");
+
+ use std::collections::HashMap;
+ use std::rc::Rc;
+ use std::cell::RefCell;
+ use list_node::ListNode;
+
+/* 哈希查找（数组） */
+fn hashing_search_array<'a>(map: &'a HashMap<i32, usize>, target: i32) -> Option<&'a usize> {
+    // 哈希表的 key: 目标元素，value: 索引
+    // 若哈希表中无此 key ，返回 None
+    map.get(&target)
+}
+
+/* 哈希查找（链表） */
+fn hashing_search_linked_list(map: &HashMap<i32, Rc<RefCell<ListNode<i32>>>>, target: i32) -> Option<&Rc<RefCell<ListNode<i32>>>> {
+    // 哈希表的 key: 目标节点值，value: 节点对象
+    // 若哈希表中无此 key ，返回 None
+    map.get(&target)
+}
+
+/* Driver Code */
+pub fn main() {
+    let target = 3;
+
+    /* 哈希查找（数组） */
+    let nums = [ 1, 5, 3, 2, 4, 7, 5, 9, 10, 8 ];
+    // 初始化哈希表
+    let mut map = HashMap::new();
+    for (i, num) in nums.iter().enumerate() {
+        map.insert(*num, i);
+    }
+    let index = hashing_search_array(&map, target);
+    println!("目标元素 3 的索引 = {}", index.unwrap());
+
+    /* 哈希查找（链表） */
+    let head = ListNode::arr_to_linked_list(&nums);
+    // 初始化哈希表
+    // let mut map1 = HashMap::new();
+    let map1 = ListNode::linked_list_to_hashmap(head);
+    let node = hashing_search_linked_list(&map1, target);
+    println!("目标节点值 3 的对应节点对象为 {:?}", node);
+}

codes/rust/chapter_searching/linear_search.rs

@@ -0,0 +1,49 @@
+/*
+ * File: linear_search.rs
+ * Created Time: 2023-07-09
+ * Author: sjinzh (sjinzh@gmail.com)
+ */
+
+ include!("../include/include.rs");
+
+ use std::rc::Rc;
+ use std::cell::RefCell;
+ use list_node::ListNode;
+
+/* 线性查找（数组） */
+fn linear_search_array(nums: &[i32], target: i32) -> i32 {
+    // 遍历数组
+    for (i, num) in nums.iter().enumerate() {
+        if num == &target {
+            return i as i32;
+        }
+    }
+    // 未找到目标元素，返回 -1
+    return -1;
+}
+
+/* 线性查找（链表） */
+fn linear_search_linked_list(head: Rc<RefCell<ListNode<i32>>>, target: i32) -> Option<Rc<RefCell<ListNode<i32>>>> {
+    // 找到目标节点，返回之
+    if head.borrow().val == target {return Some(head)};
+    if let Some(node) = &head.borrow_mut().next {
+        return linear_search_linked_list(node.clone(), target);
+    }
+    // 未找到目标节点，返回 None
+    return None;
+}
+
+/* Driver Code */
+pub fn main() {
+    let target = 3;
+
+    /* 在数组中执行线性查找 */
+    let nums = [ 1, 5, 3, 2, 4, 7, 5, 9, 10, 8 ];
+    let index = linear_search_array(&nums, target);
+    println!("目标元素 3 的索引 = {}", index);
+
+    /* 在链表中执行线性查找 */
+    let head = ListNode::arr_to_linked_list(&nums);
+    let node = linear_search_linked_list(head.unwrap(), target);
+    println!("目标节点值 3 的对应节点对象为 {:?}", node);
+}

codes/rust/include/list_node.rs

@@ -6,7 +6,9 @@
 
 use std::rc::Rc;
 use std::cell::RefCell;
+use std::collections::HashMap;
 
+#[derive(Debug)]
 pub struct ListNode<T> {
     pub val: T,
     pub next: Option<Rc<RefCell<ListNode<T>>>>,
@@ -19,4 +21,41 @@ impl<T> ListNode<T> {
             next: None,
         }))
     }
+    
+    /* Generate a linked list with an array */
+    pub fn arr_to_linked_list(array: &[T]) -> Option<Rc<RefCell<ListNode<T>>>> 
+    where
+        T: Copy + Clone,
+    {
+        let mut head = None;
+        let mut prev = None;
+        for item in array.iter().rev() {
+            let node = Rc::new(RefCell::new(ListNode {
+                val: *item,
+                next: prev.take(),
+            }));
+            prev = Some(node.clone());
+            head = Some(node);
+        }
+        head
+    }
+
+    /* Generate a hashmap with a linked_list */
+    pub fn linked_list_to_hashmap(
+        linked_list: Option<Rc<RefCell<ListNode<T>>>>,
+    ) -> HashMap<T, Rc<RefCell<ListNode<T>>>> 
+    where
+        T: std::hash::Hash + Eq + Copy + Clone
+    {
+        let mut hashmap = HashMap::new();
+        if let Some(node) = linked_list {
+            let mut current = Some(node.clone());
+            while let Some(cur) = current {
+                let borrow = cur.borrow();
+                hashmap.insert(borrow.val.clone(), cur.clone());
+                current = borrow.next.clone();
+            }
+        }
+        hashmap
+    }
 }