rustgym 0.2.0

rustgym solutions
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

struct Solution;
use rustgym_util::*;

struct Path {
    stack: Vec<i32>,
}

impl ToString for Path {
    fn to_string(&self) -> String {
        let s: Vec<String> = self.stack.iter().map(|x| x.to_string()).collect();
        s.join("->")
    }
}

trait Preorder {
    fn preorder(&self, path: &mut Path, v: &mut Vec<String>);
}

impl Preorder for TreeLink {
    fn preorder(&self, path: &mut Path, v: &mut Vec<String>) {
        if let Some(node) = self {
            let node = node.borrow();
            path.stack.push(node.val);
            if node.left.is_none() && node.right.is_none() {
                v.push(path.to_string());
            }
            if node.left.is_some() {
                node.left.preorder(path, v);
            }
            if node.right.is_some() {
                node.right.preorder(path, v);
            }
            path.stack.pop();
        }
    }
}

impl Solution {
    fn binary_tree_paths(root: TreeLink) -> Vec<String> {
        let mut path = Path { stack: vec![] };
        let mut res = vec![];
        root.preorder(&mut path, &mut res);
        res
    }
}

#[test]
fn test() {
    let root = tree!(1, tree!(2, None, tree!(5)), tree!(3));
    let paths: Vec<String> = vec_string!["1->2->5", "1->3"];
    assert_eq!(Solution::binary_tree_paths(root), paths);
}