.

Author: guangsheng.li01

src/a0701_insert_into_a_binary_search_tree.rs

@@ -0,0 +1,55 @@
+/*
+ * [0701] insert-into-a-binary-search-tree
+ */
+
+use super::utils::tree::*;
+struct Solution;
+
+use std::cell::RefCell;
+use std::rc::Rc;
+impl Solution {
+    pub fn insert_into_bst(
+        root: Option<Rc<RefCell<TreeNode>>>,
+        val: i32,
+    ) -> Option<Rc<RefCell<TreeNode>>> {
+        if let Some(root) = root.clone() {
+            let mut root = root.borrow_mut();
+
+            if val < root.val {
+                if root.left.is_none() {
+                    root.left = Some(Rc::new(RefCell::new(TreeNode {
+                        left: Option::None,
+                        right: Option::None,
+                        val: val,
+                    })))
+                } else {
+                    Self::insert_into_bst(root.left.clone(), val);
+                }
+            } else {
+                if root.right.is_none() {
+                    root.right = Some(Rc::new(RefCell::new(TreeNode {
+                        left: Option::None,
+                        right: Option::None,
+                        val: val,
+                    })))
+                } else {
+                    Self::insert_into_bst(root.right.clone(), val);
+                }
+            }
+        }
+        root
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_case0() {
+        assert_eq!(
+            Solution::insert_into_bst(tree![4, 2, 7, 1, 3], 5),
+            tree![4, 2, 7, 1, 3, 5]
+        );
+    }
+}

src/a0894_all_possible_full_binary_trees.rs

@@ -0,0 +1,68 @@
+/*
+ * [0894] all-possible-full-binary-trees
+ */
+
+use super::utils::tree::*;
+struct Solution;
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+impl Solution {
+    pub fn all_possible_fbt(n: i32) -> Vec<Option<Rc<RefCell<TreeNode>>>> {
+        let mut m: HashMap<i32, Vec<Option<Rc<RefCell<TreeNode>>>>> = HashMap::new();
+        Self::get(n, &mut m)
+    }
+
+    fn get(
+        n: i32,
+        m: &mut HashMap<i32, Vec<Option<Rc<RefCell<TreeNode>>>>>,
+    ) -> Vec<Option<Rc<RefCell<TreeNode>>>> {
+        if !m.contains_key(&n) {
+            let mut ans = Vec::new();
+            if n == 1 {
+                ans.push(Some(Rc::new(RefCell::new(TreeNode {
+                    left: Option::None,
+                    right: Option::None,
+                    val: 0,
+                }))));
+            } else if n % 2 == 1 {
+                for x in 0..n {
+                    let y = n - 1 - x;
+                    for left in Self::all_possible_fbt(x) {
+                        for right in Self::all_possible_fbt(y) {
+                            let n = Some(Rc::new(RefCell::new(TreeNode {
+                                left: left.clone(),
+                                right: right.clone(),
+                                val: 0,
+                            })));
+                            ans.push(n);
+                        }
+                    }
+                }
+            }
+            m.insert(n, ans);
+        }
+        m.get(&n).unwrap().to_vec()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_case0() {
+        assert_eq!(Solution::all_possible_fbt(1), vec![tree![0]]);
+        assert_eq!(
+            Solution::all_possible_fbt(7),
+            vec![
+                tree![0, 0, 0, null, null, 0, 0, null, null, 0, 0],
+                tree![0, 0, 0, null, null, 0, 0, 0, 0],
+                tree![0, 0, 0, 0, 0, 0, 0],
+                tree![0, 0, 0, 0, 0, null, null, null, null, 0, 0],
+                tree![0, 0, 0, 0, 0, null, null, 0, 0]
+            ]
+        );
+    }
+}

src/a0938_range_sum_of_bst.rs

@@ -0,0 +1,73 @@
+/*
+ * [0938] range-sum-of-bst
+ */
+
+use super::utils::tree::*;
+pub struct Solution {}
+
+// solution impl starts here
+
+// Definition for a binary tree node.
+// #[derive(Debug, PartialEq, Eq)]
+// pub struct TreeNode {
+//   pub val: i32,
+//   pub left: Option<Rc<RefCell<TreeNode>>>,
+//   pub right: Option<Rc<RefCell<TreeNode>>>,
+// }
+//
+// impl TreeNode {
+//   #[inline]
+//   pub fn new(val: i32) -> Self {
+//     TreeNode {
+//       val,
+//       left: None,
+//       right: None
+//     }
+//   }
+// }
+use std::cell::RefCell;
+use std::rc::Rc;
+impl Solution {
+    pub fn range_sum_bst(root: Option<Rc<RefCell<TreeNode>>>, l: i32, r: i32) -> i32 {
+        let mut sum = 0;
+        Self::dfs(root, l, r, &mut sum);
+        sum
+    }
+
+    fn dfs(root: Option<Rc<RefCell<TreeNode>>>, l: i32, r: i32, sum: &mut i32) {
+        if let Some(root) = root {
+            let root = root.borrow();
+            if root.val >= l && root.val <= r {
+                *sum += root.val;
+            }
+            if root.val > l {
+                Self::dfs(root.left.clone(), l, r, sum);
+            }
+            if root.val < r {
+                Self::dfs(root.right.clone(), l, r, sum);
+            }
+        }
+    }
+}
+// solution impl ends here
+
+// solution tests starts here
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_case0() {
+        assert_eq!(
+            Solution::range_sum_bst(tree![10, 5, 15, 3, 7, null, 18], 7, 15),
+            32
+        );
+        assert_eq!(
+            Solution::range_sum_bst(tree![10, 5, 15, 3, 7, 13, 18, 1, null, 6], 6, 10),
+            23
+        );
+    }
+}
+
+// solution tests ends here

src/lib.rs

@@ -33,11 +33,14 @@ mod a0617_merge_two_binary_trees;
 mod a0643_maximum_average_subarray_i;
 mod a0646_maximum_length_of_pair_chain;
 mod a0654_maximum_binary_tree;
+mod a0701_insert_into_a_binary_search_tree;
 mod a0867_transpose_matrix;
 mod a0883_projection_area_of_3d_shapes;
+mod a0894_all_possible_full_binary_trees;
 mod a0929_unique_email_addresses;
 mod a0931_minimum_falling_path_sum;
 mod a0937_reorder_data_in_log_files;
+mod a0938_range_sum_of_bst;
 mod a0949_largest_time_for_given_digits;
 mod a0973_k_closest_points_to_origin;
 mod a0980_unique_paths_iii;

src/main.rs

@@ -12,31 +12,23 @@ const TEMPLATE: &str = "/*
  * [{{ problem_id }}] {{ problem_title }}
  */
 
-pub struct Solution {}
-
-// solution impl starts here
+struct Solution;
 
 impl Solution {
     fn add(a: i32, b: i32) -> i32 {
         a + b
     }
 }
 
-// solution impl ends here
-
-// solution tests starts here
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_case0() {
-        assert_eq!(5, Solution::add(2, 3));
+        assert_eq!(Solution::add(2, 3), 5);
     }
 }
-
-// solution tests ends here
 ";
 
 fn main() {