q85

Author: OhBonsai

src/tree/mod.rs

@@ -22,33 +22,80 @@ impl TreeNode {
         }
     }
 
-    fn str(&self, mut lvl: usize) -> String {
-        let mut result = format!("|{}{}\x0a", "__".repeat(lvl), self.val);
-        lvl+=1;
-        match (&self.left, &self.right) {
-            (Some(l), Some(r)) => {
-                result.push_str(&(**l).borrow().str(lvl));
-                result.push_str(&(**r).borrow().str(lvl));
-            },
-            (None, Some(r)) => {
-                result.push_str(&format!("|{}null\x0a", "__".repeat(lvl)));
-                result.push_str(&(**r).borrow().str(lvl));
+    pub fn str(&self) -> String {
+        let (lines, _, _, _) = self.draw_aux();
+        lines.join("\n")
+    }
+
+    pub fn draw(&self) {
+        let (lines, _, _, _) = self.draw_aux();
+        lines.iter().map(|x| println!("{}", x)).collect::<()>();
+    }
+
+    fn draw_aux(&self) -> (Vec<String>, usize, usize, usize){
+        return match (&self.left, &self.right) {
+            (None, None) => {
+                let line = format!("{}", self.val);
+                let width = line.len();
+                let height = 1;
+                let mid = width / 2;
+                (vec!(line), width, height, mid)
             },
             (Some(l), None) => {
-                result.push_str(&(**l).borrow().str(lvl));
-                result.push_str(&format!("|{}null\x0a", "__".repeat(lvl)));
+                let (lines, n, p, x) = (**l).borrow().draw_aux();
+                let s = format!("{}", self.val);
+                let u = s.len();
+                let first_line = " ".repeat(x + 1) + &"_".repeat(n - x - 1) + &s;
+                let second_line = " ".repeat(x) + "/" + &" ".repeat(n - x - 1 + u);
+                let mut shifted_lines = lines.iter().map(|x| x.to_owned() + &" ".repeat(u)).collect::<Vec<String>>();
+                shifted_lines.insert(0, first_line);
+                shifted_lines.insert(1, second_line);
+                (shifted_lines, n + u, p + 2, n + u / 2)
             },
-            (None, None) => ()
+
+            (None, Some(r)) => {
+                let (lines, n, p, x) = (**r).borrow().draw_aux();
+                let s = format!("{}", self.val);
+                let u = s.len();
+                let first_line = s + &"_".repeat(x) + &" ".repeat(n - x);
+                let second_line = " ".repeat(u + x) + "\\" + &" ".repeat(n - x - 1);
+                let mut shifted_lines = lines.iter().map(|x| x.to_owned() + &" ".repeat(u)).collect::<Vec<String>>();
+                shifted_lines.insert(0, first_line);
+                shifted_lines.insert(1, second_line);
+                (shifted_lines, n + u, p + 2, n + u / 2)
+            },
+            (Some(l), Some(r)) => {
+                let (mut lefts, n, p, x) = (**l).borrow().draw_aux();
+                let (mut rights, m, q, y) = (**r).borrow().draw_aux();
+                let s = format!("{}", self.val);
+                let u = s.len();
+                let first_line = " ".repeat(x + 1) + &"_".repeat(n - x - 1) + &s + &"_".repeat(y) + &" ".repeat(m - y);
+                let second_line = " ".repeat(x) + "/" + &" ".repeat(n - x - 1 + u + y) + "\\" + &" ".repeat(m - y - 1);
+                if p < q {
+                    for _ in 0..(q - p) {
+                        lefts.push(" ".repeat(n))
+                    }
+                } else if q < p {
+                    for _ in 0..(p - q) {
+                        rights.push(" ".repeat(n))
+                    }
+                }
+
+                let mut shifted_lines: Vec<String> = lefts.iter().zip(rights.iter()).map(|(x, y)| x.to_owned() + &" ".repeat(u) + y).collect();
+                shifted_lines.insert(0, first_line);
+                shifted_lines.insert(1, second_line);
+                (shifted_lines, n + m + u, if p > q { p + 2 } else { q + 2 }, n + u / 2)
+            }
         }
-        result
+
     }
 }
 
 
 impl Display for TreeNode {
 
     fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        write!(f, "{}", self.str(0))
+        write!(f, "{}", self.str())
     }
 }
 
@@ -90,4 +137,6 @@ macro_rules! tree {
 }
 
 
-mod q108;
+mod q108;
+mod q95;
+mod q129;

src/tree/q108.rs

@@ -74,9 +74,11 @@ mod tests {
 
     #[test]
     fn test_1() {
-        let nums = vec!(-10,-3,0,5,9);
+        let nums = vec!(-10, -3, 0, 5, 9);
         let tree = Solution::sorted_array_to_bst(nums).unwrap();
+
         println!("{}", (*tree).borrow());
+
         assert_eq!(
             Solution::sorted_array_to_bst(vec![-10, -3, 0, 5, 9]),
             tree![0, -3, 9, -10, null, 5]

src/tree/q95.rs

@@ -0,0 +1,81 @@
+//! Given an integer n, generate all structurally unique BST's (binary search trees) that store values 1 ... n.
+//!
+//! Example:
+//! ```shell
+//! Input: 3
+//! Output:
+//! [
+//!   [1,null,3,2],
+//!   [3,2,null,1],
+//!   [3,1,null,null,2],
+//!   [2,1,3],
+//!   [1,null,2,null,3]
+//! ]
+//! Explanation:
+//! The above output corresponds to the 5 unique BST's shown below:
+//!
+//! 1         3     3      2      1
+//! \       /     /      / \      \
+//! 3     2     1      1   3      2
+//! /     /       \                 \
+//! 2     1         2                 3
+//!
+//! ```
+use super::*;
+
+
+
+struct Solution{}
+impl Solution {
+    pub fn helper(start: i32, end: i32) -> Vec<Option<Rc<RefCell<TreeNode>>>> {
+        let mut result = Vec::<Option<Rc<RefCell<TreeNode>>>>::new();
+        if start > end {
+            result.push(None);
+            return result
+        }
+
+        for i in start..=end {
+            let left_result = Solution::helper(start, i-1);
+            let right_result = Solution::helper(i+1, end);
+
+            for j in 0..left_result.len() {
+                for k in 0..right_result.len() {
+                    let mut node = TreeNode::new(i);
+                    node.left = left_result[j].clone();
+                    node.right = right_result[k].clone();
+                    result.push(Some(Rc::new(RefCell::new(node))));
+                }
+            }
+
+        }
+
+        result
+    }
+
+    pub fn generate_trees(n: i32) -> Vec<Option<Rc<RefCell<TreeNode>>>> {
+        if n == 0 {
+            vec!()
+        } else if n == 1 {
+            vec!(Some(Rc::new(RefCell::new(TreeNode::new(1)))))
+        } else {
+            Solution::helper(1, n)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        Solution::generate_trees(3).iter().map(|x| {
+            if let Some(v) = x {
+                println!("{}", (**v).borrow());
+                println!("-----------------");
+            }
+        }).collect::<()>();
+        assert_eq!(1, 1)
+    }
+}
+