feat: tree

src/solutions/mod.rs

@@ -1,9 +1,12 @@
 use std::mem;
+use std::rc::Rc;
+use std::cell::RefCell;
 
 mod add_two_numbers;
 mod array;
 mod binary_search;
 mod bt;
+mod tree;
 mod stack;
 mod container_with_most_water;
 mod dp;
@@ -78,6 +81,71 @@ pub fn reverse_list(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
     dummy
 }
 
+
+// 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
+    }
+  }
+}
+
+
+fn build_tree(
+    nums: &Vec<Option<i32>>,
+    index: usize,
+) -> Option<Rc<RefCell<TreeNode>>> {
+    if index >= nums.len() {
+        return None;
+    }
+
+    if let Some(val) = nums[index] {
+        let node = Rc::new(RefCell::new(TreeNode::new(val)));
+        node.borrow_mut().left = build_tree(nums, 2 * index + 1);
+        node.borrow_mut().right = build_tree(nums, 2 * index + 2);
+        Some(node)
+    } else {
+        None
+    }
+
+
+
+}
+
+
+pub fn vec_to_tree(v: Vec<Option<i32>>) -> Option<Rc<RefCell<TreeNode>>> {
+    if v.is_empty() { return None; }
+    build_tree(&v, 0)
+}
+
+
+fn traversal(root: Option<Rc<RefCell<TreeNode>>>, res: &mut Vec<i32>) {
+    if let Some(node) = root {
+        traversal(node.borrow().left.clone(), res);
+        res.push(node.borrow().val);
+        traversal(node.borrow().right.clone(), res);
+    }
+}
+
+pub fn inorder_traversal(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+    let mut res = vec![];
+    traversal(root, &mut res);
+    res
+
+}
+
+
 pub fn ctoi(c: char) -> usize {
     c as usize - '0' as usize
 }
@@ -117,6 +185,14 @@ mod tests {
         assert_eq!(vec![1], to_vec(reverse_head));
     }
 
+    #[test]
+    fn test_inorder_traversal() {
+        let nums = vec![Some(1),Some(2),Some(3),Some(4),Some(5)];
+        let root = vec_to_tree(nums);
+        let res = inorder_traversal(root);
+        assert_eq!(res, vec![4,2,5,1,3]);
+    }
+
     #[test]
     fn test_ctoi() {
         let c = '3';

src/solutions/three_sum.rs

@@ -52,7 +52,7 @@ mod tests {
     fn test_case_2() {
         let nums = vec![-1, 0, 1, 2, -1, -4];
         let res = Solution::three_sum(nums);
-        let expect = vec![ vec![-1, -1, 2], vec![-1, 0, 1]];
+        let expect = vec![ vec![-1, -1, 2], vec![-1, 0, 1] ];
         assert_eq!(res, expect)
     }
 }

src/solutions/tree/inorder_traversal.rs

@@ -0,0 +1,36 @@
+use crate::solutions::TreeNode;
+
+struct Solution;
+
+use std::rc::Rc;
+use std::cell::RefCell;
+impl Solution {
+    pub fn inorder_traversal(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<i32> {
+        let mut res = vec![];
+        Solution::traversal(root, &mut res);
+        res
+
+    }
+    fn traversal(root: Option<Rc<RefCell<TreeNode>>>, res: &mut Vec<i32>) {
+        if let Some(node) = root {
+            Solution::traversal(node.borrow().left.clone(), res);
+            res.push(node.borrow().val);
+            Solution::traversal(node.borrow().right.clone(), res);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::solutions::{vec_to_tree};
+
+    #[test]
+    fn test_inorder_traversal() {
+        let nums = vec![Some(1),Some(2),Some(3),Some(4),Some(5)];
+        let root = vec_to_tree(nums);
+        let res = Solution::inorder_traversal(root);
+        assert_eq!(res, vec![4,2,5,1,3]);
+
+    }
+}

src/solutions/tree/mod.rs

@@ -0,0 +1 @@
+mod inorder_traversal;