Balance a Binary Search Tree - Practice Coding Problems

Balance a Binary Search Tree - Problem

Balance a Binary Search Tree

You're given the root of a binary search tree (BST) that may be unbalanced. Your task is to transform it into a height-balanced BST while preserving all the original node values and the BST property.

A BST is considered balanced if for every node, the height difference between its left and right subtrees is at most 1. This ensures optimal search performance with O(log n) operations.

Input: Root of a binary search tree
Output: Root of a balanced binary search tree with the same values

Note: If multiple balanced BSTs are possible, you can return any valid one.

Example: [1,null,2,null,3,null,4] → [2,1,3,null,null,null,4]

Input & Output

example_1.py — Basic Unbalanced BST

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

› Output: [2,1,3,null,null,null,4] or [3,1,4,null,2] or other balanced arrangements

💡 Note: The input is a completely right-skewed BST. After balancing, we get a tree where each node's subtrees differ by at most 1 in height. Multiple valid balanced arrangements exist.

example_2.py — Left-skewed BST

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

› Output: [2,1,3,null,null,null,4] or other balanced arrangements

💡 Note: The input is left-skewed. The balanced version has node 2 or 3 as root (depending on implementation), with optimal height distribution.

example_3.py — Already Balanced

$ Input: root = [2,1,3]

› Output: [2,1,3]

💡 Note: The tree is already balanced, so we can return it as-is or any other balanced arrangement with the same values.

Visualization

Tap to expand

Understanding the Visualization

Current Structure Analysis

The company has a chain-of-command problem - too many management levels in a straight line

Employee Enumeration

List all employees by seniority level (equivalent to in-order traversal)

Choose Middle Management

Select the middle-ranked person as the department head

Divide Teams

Split remaining employees into two balanced sub-teams

Recursive Organization

Repeat the process for each sub-team to create perfect balance

Key Takeaway

🎯 Key Insight: An in-order traversal of a BST produces a sorted array, which can be used to construct a perfectly balanced BST using divide-and-conquer in O(n) time.

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Factorial time to generate all possible BST structures, times n to check balance

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and storing node values

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
1 ≤ Node.val ≤ 10⁵
All node values are unique
The input tree is guaranteed to be a valid BST

Asked in

f Facebook 45 a Amazon 38 G Google 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses in-order traversal to extract sorted values, then applies divide-and-conquer to build a balanced BST. Time: O(n), Space: O(n). Key insight: BST in-order traversal gives sorted array, perfect for balanced tree construction.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Structures)	O(n! × n)	O(n)	Generate all possible BST structures and check which one is balanced
In-order Traversal + Divide and Conquer	O(n)	O(n)	Extract sorted values via in-order traversal, then build balanced BST using divide-and-conquer

Brute Force (Try All Structures) — Algorithm Steps

Extract all values from the original BST
Generate all possible BST structures with these values
Check each structure to see if it's balanced
Return the first balanced structure found

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Values

Get all values from original BST: [1,2,3,4]

Generate Structures

Try all possible BST arrangements (exponential)

Check Balance

Test each structure for balance property

Code -

solution.c — C

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

static int values[5000];
static int valueCount = 0;

void inorder(struct TreeNode* node) {
    if (node) {
        inorder(node->left);
        values[valueCount++] = node->val;
        inorder(node->right);
    }
}

struct TreeNode* buildBalanced(int start, int end) {
    if (start > end) return NULL;
    int mid = start + (end - start) / 2;
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = values[mid];
    root->left = buildBalanced(start, mid - 1);
    root->right = buildBalanced(mid + 1, end);
    return root;
}

struct TreeNode* balanceBST(struct TreeNode* root) {
    valueCount = 0;
    inorder(root);
    return buildBalanced(0, valueCount - 1);
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Factorial time to generate all possible BST structures, times n to check balance

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and storing node values

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
1 ≤ Node.val ≤ 10⁵
All node values are unique
The input tree is guaranteed to be a valid BST

89.2K Views

Medium Frequency

~15 min Avg. Time

2.3K 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

Brute Force (Try All Structures) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler