Gjort 101

symmetric-tree-101/src/main.rs

@@ -1,33 +1,164 @@
 // Definition for a binary tree node.
- #[derive(Debug, PartialEq, Eq)]
- pub struct TreeNode {
+#[derive(Debug, PartialEq, Eq)]
+pub struct TreeNode {
     pub val: i32,
     pub left: Option<Rc<RefCell<TreeNode>>>,
     pub right: Option<Rc<RefCell<TreeNode>>>,
- }
+}
 
- impl TreeNode {
+impl TreeNode {
     #[inline]
     pub fn new(val: i32) -> Self {
         TreeNode {
             val,
             left: None,
-       right: None
-     }
+            right: None,
         }
     }
+}
 
+struct Solution {}
 
-struct Solution{}
-
-use std::rc::Rc;
 use std::cell::RefCell;
+use std::rc::Rc;
 impl Solution {
     pub fn is_symmetric(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
-        
+        if root.is_none() {
+            return true;
         }
+        let root_node = root.unwrap();
+
+        let left = root_node.borrow().left.clone();
+        let right = root_node.borrow().right.clone();
+
+        Solution::is_mirror(left, right)
+    }
+
+    pub fn is_mirror(left: Option<Rc<RefCell<TreeNode>>>, right: Option<Rc<RefCell<TreeNode>>>) -> bool {
+        match (left, right) {
+            (None, None) => true,
+
+            (Some(_), None) | (None, Some(_)) => false,
+
+            (Some(left_node), Some(right_node)) => {
+                let left_borrow = left_node.borrow();
+                let right_borrow = right_node.borrow();
+
+                left_borrow.val == right_borrow.val
+                    && Solution::is_mirror(left_borrow.left.clone(), right_borrow.right.clone())
+                    && Solution::is_mirror(left_borrow.right.clone(), right_borrow.left.clone())
+            }
+        }
+    }
+}
+
+// Helper function to create a tree node with children
+fn create_node(
+    val: i32,
+    left: Option<Rc<RefCell<TreeNode>>>,
+    right: Option<Rc<RefCell<TreeNode>>>,
+) -> Option<Rc<RefCell<TreeNode>>> {
+    let mut node = TreeNode::new(val);
+    node.left = left;
+    node.right = right;
+    Some(Rc::new(RefCell::new(node)))
 }
 
 fn main() {
-    println!("Hello, world!");
+    // Test case 1: Empty tree (should be symmetric)
+    let empty_tree: Option<Rc<RefCell<TreeNode>>> = None;
+    println!(
+        "Test case 1 (Empty tree): {}",
+        Solution::is_symmetric(empty_tree)
+    ); // Expected: true
+
+    // Test case 2: Single node tree (should be symmetric)
+    let single_node = create_node(1, None, None);
+    println!(
+        "Test case 2 (Single node): {}",
+        Solution::is_symmetric(single_node)
+    ); // Expected: true
+
+    // Test case 3: Symmetric tree
+    //      1
+    //     / \
+    //    2   2
+    //   / \ / \
+    //  3  4 4  3
+    let left_left = create_node(3, None, None);
+    let left_right = create_node(4, None, None);
+    let right_left = create_node(4, None, None);
+    let right_right = create_node(3, None, None);
+
+    let left_subtree = create_node(2, left_left, left_right);
+    let right_subtree = create_node(2, right_left, right_right);
+
+    let symmetric_tree = create_node(1, left_subtree, right_subtree);
+    println!(
+        "Test case 3 (Symmetric tree): {}",
+        Solution::is_symmetric(symmetric_tree)
+    ); // Expected: true
+
+    // Test case 4: Non-symmetric tree (different values)
+    //      1
+    //     / \
+    //    2   2
+    //   / \ / \
+    //  3  4 5  3
+    let left_left_4 = create_node(3, None, None);
+    let left_right_4 = create_node(4, None, None);
+    let right_left_4 = create_node(5, None, None); // Different value (5 instead of 4)
+    let right_right_4 = create_node(3, None, None);
+
+    let left_subtree_4 = create_node(2, left_left_4, left_right_4);
+    let right_subtree_4 = create_node(2, right_left_4, right_right_4);
+
+    let non_symmetric_values = create_node(1, left_subtree_4, right_subtree_4);
+    println!(
+        "Test case 4 (Non-symmetric values): {}",
+        Solution::is_symmetric(non_symmetric_values)
+    ); // Expected: false
+
+    // Test case 5: Non-symmetric tree (different structure)
+    //      1
+    //     / \
+    //    2   2
+    //   /     \
+    //  3       3
+    let left_left_5 = create_node(3, None, None);
+    let right_right_5 = create_node(3, None, None);
+
+    let left_subtree_5 = create_node(2, left_left_5, None);
+    let right_subtree_5 = create_node(2, None, right_right_5);
+
+    let non_symmetric_structure = create_node(1, left_subtree_5, right_subtree_5);
+    println!(
+        "Test case 5 (Non-symmetric structure): {}",
+        Solution::is_symmetric(non_symmetric_structure)
+    ); // Expected: true
+
+    // Test case 6: Complex symmetric tree
+    //         1
+    //        / \
+    //       2   2
+    //      / \ / \
+    //     3  4 4  3
+    //    /       \
+    //   5         5
+    let leaf_5_left = create_node(5, None, None);
+    let leaf_5_right = create_node(5, None, None);
+
+    let left_left_6 = create_node(3, leaf_5_left, None);
+    let left_right_6 = create_node(4, None, None);
+    let right_left_6 = create_node(4, None, None);
+    let right_right_6 = create_node(3, None, leaf_5_right);
+
+    let left_subtree_6 = create_node(2, left_left_6, left_right_6);
+    let right_subtree_6 = create_node(2, right_left_6, right_right_6);
+
+    let complex_symmetric = create_node(1, left_subtree_6, right_subtree_6);
+    println!(
+        "Test case 6 (Complex symmetric): {}",
+        Solution::is_symmetric(complex_symmetric)
+    ); // Expected: true
 }