Balanced Binary Tree - Practice Coding Problems

Balanced Binary Tree - Problem

Balance Check for Binary Trees

In the world of binary trees, balance is key to maintaining optimal performance. A height-balanced binary tree is defined as a tree where the depths of the two subtrees of every node never differ by more than 1.

🎯 Your Mission: Given the root of a binary tree, determine if it is height-balanced.

What makes a tree balanced?
For every node in the tree:
• The left and right subtrees' heights differ by at most 1
• Both left and right subtrees are also balanced

Example: [3,9,20,null,null,15,7] ✅ Balanced
Example: [1,2,2,3,3,null,null,4,4] ❌ Not balanced

This problem tests your understanding of tree traversal, recursion, and height calculation - fundamental concepts in computer science!

Input & Output

example_1.py — Python

$ Input: [3,9,20,null,null,15,7]

› Output: true

💡 Note: The tree is balanced. Root node (3) has left subtree height 1 and right subtree height 2, difference is 1 ≤ 1. All other nodes are also balanced.

example_2.py — Python

$ Input: [1,2,2,3,3,null,null,4,4]

› Output: false

💡 Note: The tree is not balanced. The left subtree has height 3 while the right subtree has height 0, giving a difference of 3 > 1.

example_3.py — Python

$ Input: []

› Output: true

💡 Note: An empty tree is considered balanced by definition.

Visualization

Tap to expand

Understanding the Visualization

Check Leaf Balance

Start with the smallest branches (leaves) - they're always balanced with height 1

Move Up the Tree

For each parent branch, check if left and right children have heights differing by at most 1

Propagate Results

If any branch is unbalanced, the whole mobile fails - return false immediately

Calculate Final Height

If balanced, return the height (1 + max of children heights) for the next level up

Key Takeaway

🎯 Key Insight: Use bottom-up traversal to calculate height and check balance simultaneously, returning -1 for imbalanced subtrees to enable early termination and avoid redundant calculations.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in the tree

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 5000]
-10⁴ ≤ Node.val ≤ 10⁴
Height-balanced: For every node, the depths of the two subtrees differ by at most 1

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 28

The optimal solution uses a bottom-up DFS approach that calculates height and checks balance in a single traversal. Key insight: return -1 to indicate imbalance and propagate it upward, avoiding redundant height calculations. This achieves O(n) time complexity compared to the brute force O(n²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Bottom-Up DFS (Optimal)	O(n)	O(h)	Calculate height and check balance in single traversal
Brute Force (Top-Down)	O(n²)	O(h)	Calculate height for each subtree separately and check balance

Bottom-Up DFS (Optimal) — Algorithm Steps

Start from leaf nodes and work upward
For each node, recursively get heights of left and right subtrees
If any subtree returns -1 (unbalanced), propagate -1 upward
If both subtrees are balanced, check current node's balance
Return -1 if unbalanced, otherwise return actual height

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from Leaves

Calculate height for leaf nodes (height = 1)

Propagate Upward

For each parent, check balance and calculate height in one pass

Early Termination

Return -1 immediately if imbalance detected

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

int dfs(struct TreeNode* node) {
    // Returns height if balanced, -1 if unbalanced
    if (!node) return 0;
    
    int leftHeight = dfs(node->left);
    if (leftHeight == -1) return -1;
    
    int rightHeight = dfs(node->right);
    if (rightHeight == -1) return -1;
    
    // Check if current node is balanced
    int diff = leftHeight - rightHeight;
    if (diff < 0) diff = -diff;
    
    if (diff > 1) return -1;
    
    return 1 + (leftHeight > rightHeight ? leftHeight : rightHeight);
}

bool isBalanced(struct TreeNode* root) {
    return dfs(root) != -1;
}

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int main() {
    char input[1000];
    if (fgets(input, sizeof(input), stdin)) {
        // Simple test case - create a basic tree
        struct TreeNode* root = createNode(3);
        root->left = createNode(9);
        root->right = createNode(20);
        root->right->left = createNode(15);
        root->right->right = createNode(7);
        
        printf("%s\n", isBalanced(root) ? "true" : "false");
    } else {
        printf("true\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in the tree

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 5000]
-10⁴ ≤ Node.val ≤ 10⁴
Height-balanced: For every node, the depths of the two subtrees differ by at most 1

67.4K Views

High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Bottom-Up DFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler