feat: update rust solution to lcof problems: No.07,33

- 面试题07. 重建二叉树
- 面试题33. 二叉搜索树的后序遍历序列

Author: YangFong

lcof/面试题07. 重建二叉树/README.md

@@ -279,18 +279,22 @@ function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
 use std::rc::Rc;
 use std::cell::RefCell;
 impl Solution {
-    pub fn build_tree(preorder: Vec<i32>, inorder: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
+    fn help(preorder: &[i32], inorder: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
         if inorder.is_empty() {
             return None;
         }
         let val = preorder[0];
         let i = inorder.iter().position(|num| *num == val).unwrap();
         Some(Rc::new(RefCell::new(TreeNode {
             val,
-            left: Self::build_tree(preorder[1..i + 1].to_vec(), inorder[..i].to_vec()),
-            right: Self::build_tree(preorder[i + 1..].to_vec(), inorder[i + 1..].to_vec()),
+            left: Self::help(&preorder[1..i + 1], &inorder[..i]),
+            right: Self::help(&preorder[i + 1..], &inorder[i + 1..]),
         })))
     }
+
+    pub fn build_tree(preorder: Vec<i32>, inorder: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
+        Self::help(&preorder, &inorder)
+    }
 }
 ```
 

lcof/面试题07. 重建二叉树/Solution.rs

@@ -19,16 +19,20 @@
 use std::rc::Rc;
 use std::cell::RefCell;
 impl Solution {
-    pub fn build_tree(preorder: Vec<i32>, inorder: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
+    fn help(preorder: &[i32], inorder: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
         if inorder.is_empty() {
             return None;
         }
         let val = preorder[0];
         let i = inorder.iter().position(|num| *num == val).unwrap();
         Some(Rc::new(RefCell::new(TreeNode {
             val,
-            left: Self::build_tree(preorder[1..i + 1].to_vec(), inorder[..i].to_vec()),
-            right: Self::build_tree(preorder[i + 1..].to_vec(), inorder[i + 1..].to_vec()),
+            left: Self::help(&preorder[1..i + 1], &inorder[..i]),
+            right: Self::help(&preorder[i + 1..], &inorder[i + 1..]),
         })))
     }
+
+    pub fn build_tree(preorder: Vec<i32>, inorder: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
+        Self::help(&preorder, &inorder)
+    }
 }

lcof/面试题33. 二叉搜索树的后序遍历序列/README.md

@@ -196,6 +196,34 @@ function verifyPostorder(postorder: number[]): boolean {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    fn dfs(start: usize, end: usize, max_val: i32, postorder: &Vec<i32>) -> bool {
+        if start >= end {
+            return true;
+        }
+        let root_val = postorder[end - 1];
+        for i in (start..end).rev() {
+            let val = postorder[i];
+            if val > max_val {
+                return false;
+            }
+            if val < root_val {
+                return Self::dfs(start, i, root_val, postorder)
+                    && Self::dfs(i + 1, end - 1, max_val, postorder);
+            }
+        }
+        Self::dfs(start, end - 1, max_val, postorder)
+    }
+
+    pub fn verify_postorder(postorder: Vec<i32>) -> bool {
+        Self::dfs(0, postorder.len(), i32::MAX, &postorder)
+    }
+}
+```
+
 ### **...**
 
 ```

lcof/面试题33. 二叉搜索树的后序遍历序列/Solution.rs

@@ -0,0 +1,23 @@
+impl Solution {
+    fn dfs(start: usize, end: usize, max_val: i32, postorder: &Vec<i32>) -> bool {
+        if start >= end {
+            return true;
+        }
+        let root_val = postorder[end - 1];
+        for i in (start..end).rev() {
+            let val = postorder[i];
+            if val > max_val {
+                return false;
+            }
+            if val < root_val {
+                return Self::dfs(start, i, root_val, postorder)
+                    && Self::dfs(i + 1, end - 1, max_val, postorder);
+            }
+        }
+        Self::dfs(start, end - 1, max_val, postorder)
+    }
+
+    pub fn verify_postorder(postorder: Vec<i32>) -> bool {
+        Self::dfs(0, postorder.len(), i32::MAX, &postorder)
+    }
+}