Balanced Binary Tree

Author: dksifoua

README.md

@@ -24,6 +24,7 @@
 | 0076 | Hard       | Minimum Window Substring                       | Hash Table, String, Sliding Window                                   | [solution](./docs/0076-Mininum-Window-Substring.md)                       |
 | 0084 | Hard       | Largest Rectangle in Histogram                 | Array, Stack, Monotonic Stack                                        | [solution](./docs/0084-Largest-Rectangle-In-Histogram.md)                 |
 | 0104 | Easy       | Maximum Depth of Binary Tree                   | Tree, Depth-First Search, Breadth-First Search, Binary Tree          | [solution](./docs/0104-Maximum-Depth-of-Binary-Tree.md)                   |
+| 0110 | Easy       | Balanced Binary Tree                           | Tree, Depth-First Search, Binary Tree                                | [solution](./docs/0110-Balanced-Binary-Tree.md)                           |
 | 0111 | Easy       | Minimum Depth of Binary Tree                   | Tree, Depth-First Search, Breadth-First Search, Binary Tree          | [solution](./docs/0111-Minimum-Depth-of-Binary-Tree.md)                   |
 | 0121 | Easy       | Best Time to Buy and Sell Stock                | Array                                                                | [solution](./docs/0121-Best-Time-to-Buy-and-Sell-Stock.md)                |
 | 0125 | Easy       | Valid Palindrome                               | String, Two Pointers                                                 | [solution](./docs/0125-Valid-Palindrome.md)                               |       

docs/0110-Balanced-Binary-Tree.md

@@ -0,0 +1,34 @@
+# [Balanced Binary Tree](https://leetcode.com/problems/balanced-binary-tree/description/)
+
+## Intuition
+
+A binary tree is considered height-balanced if the depth of the left and right subtrees of every node differ by no more
+than one. To check if a tree is balanced, we can use a depth-first search (DFS) to compute the height of each subtree
+and simultaneously check for balance at each node.
+
+## Approach
+
+1. **DFS for Height and Balance Check:**
+    - Use a helper method `dfsHeight to recursively calculate the height of each subtree.
+    - For each node, calculate the heights of its left and right subtrees.
+    - If the difference in height between the left and right subtrees is greater than 1, set a result flag to false,
+      indicating the tree is not balanced.
+    - Return the height of the current node as `1 + max(left, right)` to propagate the height up the recursion stack.
+2. **Global Balance Tracking:**
+    - Use a boolean array result initialized to true. If any node is found to be unbalanced, the result flag is set to
+      false.
+    - Start the recursive check from the root node.
+3. **Return the Result:** After the recursion completes, result[0] will indicate whether the tree is balanced.
+
+## Complexity
+
+- **Time Complexity: `O(n`**, where `n` is the number of nodes in the tree. Each node is visited once to calculate its
+  height and check for balance.
+- **Space Complexity: `O(h)`**, where `h` is is the height of the tree. This represents the space used by the recursive
+  call stack. In the worst case (skewed tree), `h = n`, and in the best case (balanced tree), `h=log(n)`.
+
+## Summary
+
+This solution determines if a binary tree is balanced by recursively calculating the height of each subtree while
+checking the balance condition at each node. By tracking the balance in a boolean array, we ensure efficient checking
+with a single traversal. The approach meets the requirements with `O(n) time complexity.

src/main/java/io/dksifoua/leetcode/balancedbinarytree/Solution.java

@@ -0,0 +1,27 @@
+package io.dksifoua.leetcode.balancedbinarytree;
+
+import io.dksifoua.leetcode.utils.TreeNode;
+
+public class Solution {
+
+    private int dfsHeight(TreeNode root, boolean[] result) {
+        if (root == null) {
+            return 0;
+        }
+
+        int left = this.dfsHeight(root.getLeft(), result);
+        int right = this.dfsHeight(root.getRight(), result);
+
+        if (Math.abs(left - right) > 1) {
+            result[0] = false;
+        }
+
+        return 1 + Math.max(left, right);
+    }
+
+    public boolean isBalanced(TreeNode root) {
+        boolean[] result = new boolean[] { true };
+        this.dfsHeight(root, result);
+        return result[0];
+    }
+}

src/test/java/io/dksifoua/leetcode/balancedbinarytree/SolutionTest.java

@@ -0,0 +1,22 @@
+package io.dksifoua.leetcode.balancedbinarytree;
+
+import io.dksifoua.leetcode.utils.TreeNode;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class SolutionTest {
+
+    final Solution solution = new Solution();
+
+    @Test
+    void test1() {
+        assertTrue(solution.isBalanced(TreeNode.build(new Integer[] { 3, 9, 20, null, null, 15, 7 })));
+    }
+
+    @Test
+    void test2() {
+        assertFalse(solution.isBalanced(TreeNode.build(new Integer[] { 1, 2, 2, 3, 3, null, null, 4, 4 })));
+    }
+}