feat: mark done and rename max to maximum depth of binary tree

Author: bujosa

src/easy/max_depth_of_binary_tree.rs

@@ -0,0 +1,89 @@
+#![allow(dead_code)]
+use std::cell::RefCell;
+use std::rc::Rc;
+
+type Tree = Option<Rc<RefCell<TreeNode>>>;
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct TreeNode {
+    pub val: i32,
+    pub left: Tree,
+    pub right: Tree,
+}
+
+impl TreeNode {
+    #[inline]
+    pub fn new(val: i32) -> Self {
+        TreeNode {
+            val,
+            left: None,
+            right: None,
+        }
+    }
+}
+
+pub fn max_depth(root: Tree) -> i32 {
+    if root.is_none() {
+        return 0;
+    }
+
+    let left_depth = max_depth(root.as_ref().unwrap().borrow().left.clone());
+    let right_depth = max_depth(root.as_ref().unwrap().borrow().right.clone());
+
+    return 1 + std::cmp::max(left_depth, right_depth);
+}
+
+/*
+   Algorithm - Recursive DFS (Depth First Search)
+    - If the root is None, return 0
+     - Get the max depth of the left subtree
+     - Get the max depth of the right subtree
+     - Return 1 + the max of the left and right subtree
+
+   Complexity
+       - Time: O(n)
+       - Space: O(n)
+*/
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1() {
+        let mut root = TreeNode::new(3);
+        let mut left = TreeNode::new(9);
+        let right = TreeNode::new(20);
+        let left_left = TreeNode::new(15);
+        let left_right = TreeNode::new(7);
+
+        left.left = Some(Rc::new(RefCell::new(left_left)));
+        left.right = Some(Rc::new(RefCell::new(left_right)));
+        root.left = Some(Rc::new(RefCell::new(left)));
+        root.right = Some(Rc::new(RefCell::new(right)));
+
+        assert_eq!(max_depth(Some(Rc::new(RefCell::new(root)))), 3);
+    }
+
+    #[test]
+    fn test_2() {
+        let mut root = TreeNode::new(1);
+        let left = TreeNode::new(2);
+
+        root.left = Some(Rc::new(RefCell::new(left)));
+
+        assert_eq!(max_depth(Some(Rc::new(RefCell::new(root)))), 2);
+    }
+
+    #[test]
+    fn test_3() {
+        let root = TreeNode::new(0);
+
+        assert_eq!(max_depth(Some(Rc::new(RefCell::new(root)))), 1);
+    }
+
+    #[test]
+    fn test_4() {
+        assert_eq!(max_depth(None), 0);
+    }
+}

src/easy/maximum_depth_of_binary_tree.rs

@@ -12,7 +12,6 @@ pub mod invert_binary_tree;
 pub mod length_of_last_word;
 pub mod linked_list_cycle;
 pub mod longest_common_prefix;
-pub mod max_depth_of_binary_tree;
 pub mod maximum_depth_of_binary_tree;
 pub mod merge_sorted_array;
 pub mod merge_two_sorted_lists;

src/easy/mod.rs

@@ -61,7 +61,7 @@
 ## Problems
 
 - [x] [Invert Binary Tree](https://leetcode.com/problems/invert-binary-tree/) | Easy | [Solution](../../../src/easy/invert_binary_tree.rs) | [Problem Description](../../../src/easy/readme.md#226-invert-binary-tree)
-- [ ] [Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/) | Easy | [Solution](../../../src/easy/maximum_depth_of_binary_tree.rs) | [Problem Description](../../../src/easy/readme.md#104-maximum-depth-of-binary-tree)
+- [x] [Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/) | Easy | [Solution](../../../src/easy/maximum_depth_of_binary_tree.rs) | [Problem Description](../../../src/easy/readme.md#104-maximum-depth-of-binary-tree)
 - [ ] [Diameter of Binary Tree](https://leetcode.com/problems/diameter-of-binary-tree/) | Easy | [Solution](../../../src/easy/diameter_of_binary_tree.rs) | [Problem Description](../../../src/easy/readme.md#543-diameter-of-binary-tree)
 - [ ] [Balanced Binary Tree](https://leetcode.com/problems/balanced-binary-tree/) | Easy | [Solution](../../../src/easy/balanced_binary_tree.rs) | [Problem Description](../../../src/easy/readme.md#110-balanced-binary-tree)
 - [ ] [Same Tree](https://leetcode.com/problems/same-tree/) | Easy | [Solution](../../../src/easy/same_tree.rs) | [Problem Description](../../../src/easy/readme.md#100-same-tree)