Binary Trees

    
//Definition for a binary tree node.
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : 
        val(0), 
        left(nullptr), 
        right(nullptr) {}
    TreeNode(int x) : 
        val(x), 
        left(nullptr), 
        right(nullptr) {}
    TreeNode(
        int x, 
        TreeNode *left, 
        TreeNode *right
        ):
    val(x), left(left), right(right) {}
};

                    

    
// Definition for a binary tree node.
#[derive(Debug, PartialEq, Eq)]
pub struct TreeNode {
pub val: i32,
pub left: Option>>,
pub right: Option>>,
}

impl TreeNode {
#[inline]
pub fn new(val: i32) -> Self {
    TreeNode {
    val,
    left: None,
    right: None
    }
}
}
                    

    
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
                    

   
void inorder(TreeNode* root)
                    

   
fn inorder(
    root: &Option>>
        )
                    

   
def leafSimilar(
    self, root1: Optional[TreeNode]
    )
                    

    
if (!root)
    return;
                    

    
fn inorder(
    root: &Option>>, 
    tree: &mut Vec) {
    if let Some(node) = root {
        Solution::inorder(
            &node.borrow().left, 
            tree);
        if node.borrow().left.is_none() 
           && 
           node.borrow().right.is_none() {
            tree.push(node.borrow().val);
        }
        Solution::inorder(
            &node.borrow().right, 
            tree);
    }
}
                    

   
def inorder(root: Optional[TreeNode], tree: []):
    if root == None:
        return
    inorder (root.left, tree)