From 681be3accc6564a9a38b9c63679af5fb9ba56e45 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?H=C3=A5kon=20St=C3=B8rdal?= <30749741+hakon55@users.noreply.github.com> Date: Sat, 22 Mar 2025 15:04:49 +0100 Subject: [PATCH] Gjort 101 --- symmetric-tree-101/src/main.rs | 185 ++++++++++++++++++++++++++++----- 1 file changed, 158 insertions(+), 27 deletions(-) diff --git a/symmetric-tree-101/src/main.rs b/symmetric-tree-101/src/main.rs index 078ce90..a8df7e2 100644 --- a/symmetric-tree-101/src/main.rs +++ b/symmetric-tree-101/src/main.rs @@ -1,33 +1,164 @@ // 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 - } - } - } +#[derive(Debug, PartialEq, Eq)] +pub struct TreeNode { + pub val: i32, + pub left: Option>>, + pub right: Option>>, +} - -struct Solution{} - -use std::rc::Rc; -use std::cell::RefCell; -impl Solution { - pub fn is_symmetric(root: Option>>) -> bool { - +impl TreeNode { + #[inline] + pub fn new(val: i32) -> Self { + TreeNode { + val, + left: None, + right: None, + } } } -fn main() { - println!("Hello, world!"); +struct Solution {} + +use std::cell::RefCell; +use std::rc::Rc; +impl Solution { + pub fn is_symmetric(root: Option>>) -> 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>>, right: Option>>) -> 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>>, + right: Option>>, +) -> Option>> { + let mut node = TreeNode::new(val); + node.left = left; + node.right = right; + Some(Rc::new(RefCell::new(node))) +} + +fn main() { + // Test case 1: Empty tree (should be symmetric) + let empty_tree: Option>> = 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 }