'Balanced Binary Tree' soln

Author: joewnga

README.md

@@ -115,8 +115,8 @@ Note: Some solutions have multiple approaches implemented
 | 107 | [Binary Tree Level Order Traversal II](https://leetcode.com/problems/binary-tree-level-order-traversal-ii/) | [Solution](./leetcode/binary_tree_level_order_traversal_ii.rs) | Medium |
 | 108 | [Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/) | [Solution](./leetcode/convert_sorted_array_to_bst.rs) | Easy |
 | 109 | [Convert Sorted List to Binary Search Tree](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/) | [Solution](./leetcode/convert_sorted_list_to_bst.rs) | Medium |
-| >110 | [Balanced Binary Tree](https://leetcode.com/problems/balanced-binary-tree/) | [Solution](./leetcode/balanced_binary_tree.rs) | Easy |
-| 111 | [Minimum Depth of Binary Tree](https://leetcode.com/problems/minimum-depth-of-binary-tree/) | [Solution](./leetcode/minimum_depth_of_binary_tree.rs) | Easy |
+| 110 | [Balanced Binary Tree](https://leetcode.com/problems/balanced-binary-tree/) | [Solution](./leetcode/balanced_binary_tree.rs) | Easy |
+| >111 | [Minimum Depth of Binary Tree](https://leetcode.com/problems/minimum-depth-of-binary-tree/) | [Solution](./leetcode/minimum_depth_of_binary_tree.rs) | Easy |
 | 112 | [Path Sum](https://leetcode.com/problems/path-sum/) | [Solution](./leetcode/path_sum.rs) | Easy |
 | 113 | [Path Sum II](https://leetcode.com/problems/path-sum-ii/) | [Solution](./leetcode/path_sum_ii.rs) | Medium |
 | 114 | [Flatten Binary Tree to Linked List](https://leetcode.com/problems/flatten-binary-tree-to-linked-list/) | [Solution](./leetcode/flatten_binary_tree.rs) | Medium |

leetcode/balanced_binary_tree.rs

@@ -0,0 +1,85 @@
+/// 
+/// Problem: Balanced Binary Tree
+/// 
+/// Given a binary tree, determine if it is height-balanced.
+/// 
+/// A height-balanced binary tree is defined as a binary tree in which the depth of the 
+/// two subtrees of every node never differ by more than 1.
+/// 
+/// Example 1:
+/// Input: root = [3,9,20,null,null,15,7]
+/// Output: true
+/// 
+/// Example 2:
+/// Input: root = [1,2,2,3,3,null,null,4,4]
+/// Output: false
+/// 
+/// Example 3:
+/// Input: root = []
+/// Output: true
+/// 
+/// Constraints:
+/// The number of nodes in the tree is in the range [0, 5000].
+/// -10^4 <= Node.val <= 10^4
+/// 
+
+// Definition for a binary tree node (provided by LeetCode)
+// #[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
+//     }
+//   }
+// }
+
+// # Solution:
+// Time complexity: O(n²)
+// Space complexity: O(n)
+
+use std::rc::Rc;
+use std::cell::RefCell;
+use std::cmp;
+impl Solution {
+    pub fn is_balanced(root: Option<Rc<RefCell<TreeNode>>>) -> bool {
+        if root.is_none() {
+           return true;
+       }
+       
+       let node = root.unwrap();
+       let node_ref = node.borrow();
+       
+       // Get heights of left and right subtrees
+       let left_height = Self::height(node_ref.left.clone());
+       let right_height = Self::height(node_ref.right.clone());
+       
+       // Check if current node is balanced and recursively check children
+       (left_height - right_height).abs() <= 1 
+           && Self::is_balanced(node_ref.left.clone()) 
+           && Self::is_balanced(node_ref.right.clone())
+   }
+   
+   
+   fn height(root: Option<Rc<RefCell<TreeNode>>>) -> i32 {
+       if root.is_none() {
+           return 0;
+       }
+       
+       let node = root.unwrap();
+       let node_ref = node.borrow();
+       
+       1 + cmp::max(
+           Self::height(node_ref.left.clone()),
+           Self::height(node_ref.right.clone())
+       )
+    }
+}