Solve 23/75

README.md

···
 
 #### Array & Hashing
 
-- [ ] Contains Duplicate
+- [x] Contains Duplicate
       [[#217]](https://leetcode.com/problems/contains-duplicate/)
+      [src/array_hashing/contains_duplicate.rs](src/array_hashing/contains_duplicate.rs)
 - [x] Valid Anagram
       [[#242]](https://leetcode.com/problems/valid-anagram/)
-      src/array_hashing/is_anagram.rs
+      [src/array_hashing/is_anagram.rs](src/array_hashing/is_anagram.rs)
 - [x] Two Sum
       [[#1]](https://leetcode.com/problems/two-sum/)
-      src/array_hashing/two_sum.rs
-- [ ] Group Anagrams
+      [src/array_hashing/two_sum.rs](src/array_hashing/two_sum.rs)
+- [x] Group Anagrams
       [[#49]](https://leetcode.com/problems/group-anagrams/)
+      [src/array_hashing/group_anagrams.rs](src/array_hashing/group_anagrams.rs)
 - [ ] Top K Frequent Elements
       [[#347]](https://leetcode.com/problems/top-k-frequent-elements/)
 - [ ] Encode and Decode Strings
···
 
 #### Trees
 
-- [ ] Invert Binary Tree
+- [x] Invert Binary Tree
       [[#226]](https://leetcode.com/problems/invert-binary-tree/)
-- [ ] Maximum Depth of Binary Tree
+      src/trees/invert_tree.rs
+- [x] Maximum Depth of Binary Tree
       [[#104]](https://leetcode.com/problems/maximum-depth-of-binary-tree/)
-- [ ] Same Tree
+      src/trees/max_depth.rs
+- [x] Same Tree
       [[#100]](https://leetcode.com/problems/same-tree/)
+      src/trees/is_same_tree.rs
 - [ ] Subtree of Another Tree
       [[#572]](https://leetcode.com/problems/subtree-of-another-tree/)
 - [ ] Lowest Common Ancestor of a Binary Search Tree

src/array_hashing/contains_duplicate.rs

···
+use std::collections::HashSet;
+
+pub fn contains_duplicate(nums: Vec<i32>) -> bool {
+    let mut hash = HashSet::new();
+    for num in nums {
+        if hash.contains(&num) {
+            return true;
+        }
+        hash.insert(num);
+    }
+    return false;
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::array_hashing::contains_duplicate::contains_duplicate;
+
+    #[test]
+    fn case_1() {
+        assert_eq!(contains_duplicate(vec![1, 2, 3, 1]), true);
+        assert_eq!(contains_duplicate(vec![1, 2, 3, 4]), false);
+        assert_eq!(contains_duplicate(vec![1, 1, 1, 3, 3, 4, 3, 2, 4, 2]), true);
+    }
+}

src/array_hashing/group_anagrams.rs

···
+use std::collections::HashMap;
+
+pub fn group_anagrams(strs: Vec<String>) -> Vec<Vec<String>> {
+    let mut map: HashMap<[u8; 26], Vec<String>> = HashMap::with_capacity(strs.len());
+
+    for s in strs {
+        let mut key = [0u8; 26];
+        for b in s.as_bytes() {
+            unsafe {
+                *key.get_unchecked_mut((b - b'a') as usize) += 1;
+            }
+        }
+        map.entry(key).or_default().push(s);
+    }
+
+    map.into_values().collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::array_hashing::group_anagrams::group_anagrams;
+
+    fn sort_anagram_groups(groups: Vec<Vec<String>>) -> Vec<Vec<String>> {
+        let mut groups = groups;
+        for group in groups.iter_mut() {
+            group.sort();
+        }
+        groups.sort_by(|a, b| a[0].cmp(&b[0]));
+        groups
+    }
+
+    #[test]
+    fn case_1() {
+        assert_eq!(
+            sort_anagram_groups(group_anagrams(vec![
+                "eat".to_string(),
+                "tea".to_string(),
+                "tan".to_string(),
+                "ate".to_string(),
+                "nat".to_string(),
+                "bat".to_string()
+            ])),
+            sort_anagram_groups(vec![
+                vec!["bat".to_string()],
+                vec!["nat".to_string(), "tan".to_string()],
+                vec!["ate".to_string(), "eat".to_string(), "tea".to_string()]
+            ])
+        );
+    }
+}

src/array_hashing/mod.rs

···
+pub mod contains_duplicate;
+pub mod group_anagrams;
 pub mod is_anagram;
 pub mod two_sum;

src/lib.rs

···
 pub mod linked_list;
 pub mod sliding_window;
 pub mod stack;
+pub mod trees;
 pub mod two_pointers;

src/trees/invert_tree.rs

···
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use crate::trees::TreeNode;
+
+pub fn invert_tree(root: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
+    if let Some(node) = root.as_ref() {
+        let mut node_borrow = node.borrow_mut();
+
+        let left = node_borrow.left.take();
+        let right = node_borrow.right.take();
+
+        node_borrow.left = invert_tree(right);
+        node_borrow.right = invert_tree(left);
+    }
+
+    root
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Helper function to create a node wrapped in Rc/RefCell
+    fn create_node(val: i32) -> Option<Rc<RefCell<TreeNode>>> {
+        Some(Rc::new(RefCell::new(TreeNode::new(val))))
+    }
+
+    #[test]
+    fn test_empty_tree() {
+        assert_eq!(invert_tree(None), None);
+    }
+
+    #[test]
+    fn test_single_node() {
+        let root = create_node(1);
+        let result = invert_tree(root.clone());
+        assert_eq!(result, root);
+    }
+
+    #[test]
+    fn test_simple_inversion() {
+        /*
+            Original:      Inverted:
+               1              1
+              / \            / \
+             2   3          3   2
+        */
+        let root = create_node(1);
+        let left = create_node(2);
+        let right = create_node(3);
+
+        root.as_ref().unwrap().borrow_mut().left = left;
+        root.as_ref().unwrap().borrow_mut().right = right;
+
+        let inverted = invert_tree(root);
+        let binding = inverted.unwrap();
+        let result_node = binding.borrow();
+
+        assert_eq!(result_node.val, 1);
+        assert_eq!(result_node.left.as_ref().unwrap().borrow().val, 3);
+        assert_eq!(result_node.right.as_ref().unwrap().borrow().val, 2);
+    }
+
+    #[test]
+    fn test_complex_tree() {
+        /*
+            Original:           Inverted:
+                4                   4
+              /   \               /   \
+             2     7             7     2
+            / \   / \           / \   / \
+           1   3 6   9         9   6 3   1
+        */
+        let root = create_node(4);
+
+        // Left subtree
+        let n2 = create_node(2);
+        n2.as_ref().unwrap().borrow_mut().left = create_node(1);
+        n2.as_ref().unwrap().borrow_mut().right = create_node(3);
+
+        // Right subtree
+        let n7 = create_node(7);
+        n7.as_ref().unwrap().borrow_mut().left = create_node(6);
+        n7.as_ref().unwrap().borrow_mut().right = create_node(9);
+
+        root.as_ref().unwrap().borrow_mut().left = n2;
+        root.as_ref().unwrap().borrow_mut().right = n7;
+
+        let inverted_root = invert_tree(root).unwrap();
+        let root_borrow = inverted_root.borrow();
+
+        // Check level 1
+        let left_child = root_borrow.left.as_ref().unwrap().borrow();
+        let right_child = root_borrow.right.as_ref().unwrap().borrow();
+        assert_eq!(left_child.val, 7);
+        assert_eq!(right_child.val, 2);
+
+        // Check level 2 (deepest nodes)
+        assert_eq!(left_child.left.as_ref().unwrap().borrow().val, 9);
+        assert_eq!(left_child.right.as_ref().unwrap().borrow().val, 6);
+        assert_eq!(right_child.left.as_ref().unwrap().borrow().val, 3);
+        assert_eq!(right_child.right.as_ref().unwrap().borrow().val, 1);
+    }
+}

src/trees/is_same_tree.rs

···
+use std::{cell::RefCell, rc::Rc};
+
+use crate::trees::TreeNode;
+
+pub fn is_same_tree(p: Option<Rc<RefCell<TreeNode>>>, q: Option<Rc<RefCell<TreeNode>>>) -> bool {
+    match (p, q) {
+        (None, None) => true,
+
+        (Some(p_node), Some(q_node)) => {
+            let p_ref = p_node.borrow();
+            let q_ref = q_node.borrow();
+
+            p_ref.val == q_ref.val
+                && is_same_tree(p_ref.left.clone(), q_ref.left.clone())
+                && is_same_tree(p_ref.right.clone(), q_ref.right.clone())
+        }
+
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn node(
+        val: i32,
+        left: Option<Rc<RefCell<TreeNode>>>,
+        right: Option<Rc<RefCell<TreeNode>>>,
+    ) -> Option<Rc<RefCell<TreeNode>>> {
+        Some(Rc::new(RefCell::new(TreeNode { val, left, right })))
+    }
+
+    #[test]
+    fn test_identical_trees() {
+        // Tree p: [1, 2, 3]
+        let p = node(1, node(2, None, None), node(3, None, None));
+        // Tree q: [1, 2, 3]
+        let q = node(1, node(2, None, None), node(3, None, None));
+        assert!(is_same_tree(p, q));
+    }
+
+    #[test]
+    fn test_different_structure() {
+        // Tree p: [1, 2]
+        let p = node(1, node(2, None, None), None);
+        // Tree q: [1, null, 2]
+        let q = node(1, None, node(2, None, None));
+        assert!(!is_same_tree(p, q));
+    }
+
+    #[test]
+    fn test_different_values() {
+        // Tree p: [1, 2, 1]
+        let p = node(1, node(2, None, None), node(1, None, None));
+        // Tree q: [1, 1, 2]
+        let q = node(1, node(1, None, None), node(2, None, None));
+        assert!(!is_same_tree(p, q));
+    }
+
+    #[test]
+    fn test_empty_trees() {
+        assert!(is_same_tree(None, None));
+    }
+}

src/trees/max_depth.rs

···
+use std::collections::VecDeque;
+use std::{cell::RefCell, rc::Rc};
+
+use crate::trees::TreeNode;
+
+// iterative approach BFS
+pub fn max_depth_tabulation_bfs(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+    let root = match root {
+        None => return 0,
+        Some(node) => node,
+    };
+
+    let mut queue = VecDeque::new();
+    queue.push_back(root);
+    let mut depth = 0;
+
+    while !queue.is_empty() {
+        depth += 1;
+
+        let level_size = queue.len();
+
+        for _ in 0..level_size {
+            if let Some(node) = queue.pop_front() {
+                let node_ref = node.borrow();
+
+                if let Some(left) = node_ref.left.clone() {
+                    queue.push_back(left);
+                }
+                if let Some(right) = node_ref.right.clone() {
+                    queue.push_back(right);
+                }
+            }
+        }
+    }
+
+    depth
+}
+
+pub fn max_depth_tabulation_dfs(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+    let root_node = match root {
+        None => return 0,
+        Some(node) => node,
+    };
+
+    let mut max_depth = 0;
+    let mut stack = vec![(root_node, 1)];
+
+    while let Some((node, current_depth)) = stack.pop() {
+        max_depth = max_depth.max(current_depth);
+
+        let node_ref = node.borrow();
+
+        if let Some(right) = node_ref.right.clone() {
+            stack.push((right, current_depth + 1));
+        }
+        if let Some(left) = node_ref.left.clone() {
+            stack.push((left, current_depth + 1));
+        }
+    }
+
+    max_depth
+}
+
+pub fn max_depth(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+    match root {
+        None => 0,
+        Some(node) => {
+            let node_ref = node.borrow();
+            let left_depth = max_depth(node_ref.left.clone());
+            let right_depth = max_depth(node_ref.right.clone());
+            1 + left_depth.max(right_depth)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::VecDeque;
+
+    // Helper function to build a tree from a LeetCode-style vector
+    fn to_tree(elements: Vec<Option<i32>>) -> Option<Rc<RefCell<TreeNode>>> {
+        if elements.is_empty() || elements[0].is_none() {
+            return None;
+        }
+
+        let root = Rc::new(RefCell::new(TreeNode::new(elements[0].unwrap())));
+        let mut queue = VecDeque::new();
+        queue.push_back(Rc::clone(&root));
+
+        let mut i = 1;
+        while i < elements.len() {
+            if let Some(node) = queue.pop_front() {
+                // Left Child
+                if i < elements.len() {
+                    if let Some(val) = elements[i] {
+                        let left_node = Rc::new(RefCell::new(TreeNode::new(val)));
+                        node.borrow_mut().left = Some(Rc::clone(&left_node));
+                        queue.push_back(left_node);
+                    }
+                    i += 1;
+                }
+                // Right Child
+                if i < elements.len() {
+                    if let Some(val) = elements[i] {
+                        let right_node = Rc::new(RefCell::new(TreeNode::new(val)));
+                        node.borrow_mut().right = Some(Rc::clone(&right_node));
+                        queue.push_back(right_node);
+                    }
+                    i += 1;
+                }
+            }
+        }
+        Some(root)
+    }
+
+    #[test]
+    fn test_example_1() {
+        // root = [3,9,20,null,null,15,7]
+        let root = to_tree(vec![
+            Some(3),
+            Some(9),
+            Some(20),
+            None,
+            None,
+            Some(15),
+            Some(7),
+        ]);
+        assert_eq!(max_depth(root), 3);
+    }
+
+    #[test]
+    fn test_example_2() {
+        // root = [1,null,2]
+        let root = to_tree(vec![Some(1), None, Some(2)]);
+        assert_eq!(max_depth(root), 2);
+    }
+
+    #[test]
+    fn test_empty_tree() {
+        let root = to_tree(vec![]);
+        assert_eq!(max_depth(root), 0);
+    }
+
+    #[test]
+    fn test_single_node() {
+        let root = to_tree(vec![Some(1)]);
+        assert_eq!(max_depth(root), 1);
+    }
+
+    #[test]
+    fn test_skewed_tree() {
+        // 1 -> 2 -> 3 -> 4 (all left)
+        let root = to_tree(vec![Some(1), Some(2), None, Some(3), None, Some(4)]);
+        assert_eq!(max_depth(root), 4);
+    }
+}

src/trees/mod.rs

···
+use std::{cell::RefCell, rc::Rc};
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct TreeNode {
+    pub val: i32,
+    pub left: Option<Rc<RefCell<TreeNode>>>,
+    pub right: Option<Rc<RefCell<TreeNode>>>,
+}
+
+impl TreeNode {
+    #[inline]
+    pub fn new(val: i32) -> Self {
+        TreeNode {
+            val,
+            left: None,
+            right: None,
+        }
+    }
+}
+
+pub mod invert_tree;
+pub mod is_same_tree;
+pub mod max_depth;