add 95;104;107;108;110

Author: leopsidom

104.maximum-depth-of-binary-tree.rs

@@ -0,0 +1,44 @@
+/*
+ * @lc app=leetcode id=104 lang=rust
+ *
+ * [104] Maximum Depth of Binary Tree
+ */
+
+// @lc code=start
+// 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::rc::Rc;
+use std::cell::RefCell;
+use std::cmp;
+
+impl Solution {
+    pub fn max_depth(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+        match root {
+            None => 0,
+            Some(node) => {
+                1 + cmp::max(
+                    Self::max_depth(node.borrow().left.clone()),
+                    Self::max_depth(node.borrow().right.clone())
+                )
+            }
+        }
+    }
+}
+// @lc code=end
+

107.binary-tree-level-order-traversal-ii.rs

@@ -0,0 +1,61 @@
+/*
+ * @lc app=leetcode id=107 lang=rust
+ *
+ * [107] Binary Tree Level Order Traversal II
+ */
+
+// @lc code=start
+// 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::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn level_order_bottom(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
+        if root.is_none() { return vec![]; }
+
+        let mut nodes = vec![root.clone()];
+        let mut ans = vec![];
+
+        while nodes.len() > 0 {
+            let mut tmp = vec![];
+            let mut vals = vec![];
+
+            for node in nodes {
+                if let Some(node_inner) = node {
+                    let tree_node = node_inner.borrow();
+                    vals.push(tree_node.val);
+                    if tree_node.left.is_some() {
+                        tmp.push(tree_node.left.clone());
+                    }
+                    if tree_node.right.is_some() {
+                        tmp.push(tree_node.right.clone());
+                    }
+                }
+            }
+
+            nodes = tmp;
+            ans.push(vals);
+        }
+
+        ans.reverse();
+        ans
+    }
+}
+// @lc code=end
+

108.convert-sorted-array-to-binary-search-tree.rs

@@ -0,0 +1,47 @@
+/*
+ * @lc app=leetcode id=108 lang=rust
+ *
+ * [108] Convert Sorted Array to Binary Search Tree
+ */
+
+// @lc code=start
+// 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::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn sorted_array_to_bst(nums: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
+        fn helper(nums: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
+            let N = nums.len();
+            if N == 0 { return None; }
+
+            let mid = N / 2;
+            let mut tree_node = TreeNode::new(nums[mid]);
+
+            tree_node.left = helper(&nums[0..mid]);
+            tree_node.right = helper(&nums[mid+1..N]);
+
+            Some(Rc::new(RefCell::new(tree_node)))
+        }
+
+        helper(&nums[..])
+    }
+}
+// @lc code=end
+

110.balanced-binary-tree.rs

@@ -0,0 +1,34 @@
+/*
+ * @lc app=leetcode id=110 lang=rust
+ *
+ * [110] Balanced Binary Tree
+ */
+
+// @lc code=start
+// 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::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn is_balanced(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
+        
+    }
+}
+// @lc code=end
+

95.unique-binary-search-trees-ii.rs

@@ -0,0 +1,61 @@
+/*
+ * @lc app=leetcode id=95 lang=rust
+ *
+ * [95] Unique Binary Search Trees II
+ */
+
+// @lc code=start
+// 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::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn generate_trees(n: i32) -> Vec<Option<Rc<RefCell<TreeNode>>>> {
+        fn helper(start: i32, end: i32) -> Vec<Option<Rc<RefCell<TreeNode>>>> {
+            let mut ans = vec![];
+
+            if start > end {
+                ans.push(None);
+                return ans;
+            }
+
+            for i in start..end+1 {
+                
+                for left in helper(start, i-1) {
+                    for right in helper(i+1, end) {
+                        let tree_node = Rc::new(RefCell::new(TreeNode::new(i)));
+                        tree_node.borrow_mut().left = left.clone();
+                        tree_node.borrow_mut().right = right.clone();
+                        // if let Some(node) = right.clone() {
+                        //     println!("i: {}, right: {}", i, node.borrow().val);
+                        // }
+                        ans.push(Some(tree_node));
+                    }
+                }
+            }
+
+            ans
+        }
+
+        if n == 0 { return vec![]; }
+        helper(1, n)
+    }
+}
+// @lc code=end
+