BST to Balanced BST - Problem

Given an unbalanced Binary Search Tree (BST), convert it into a height-balanced BST.

A height-balanced BST is defined as a binary tree where the depth of the left and right subtrees of every node differs by at most 1.

The converted BST should maintain the BST property: for every node, all values in the left subtree are smaller, and all values in the right subtree are larger.

Note: Return the root of the balanced BST. Multiple valid balanced BSTs are possible - return any one of them.

Input & Output

Example 1 — Unbalanced Right-Heavy BST

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

› Output: [2,1,3,null,null,null,4]

💡 Note: The original BST is completely right-heavy like a linked list. After balancing, node 2 becomes root with 1 on left and 3 on right, with 4 as right child of 3.

Example 2 — Simple Unbalanced Tree

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

› Output: [2,1,3]

💡 Note: The tree is already balanced with height difference ≤ 1 between subtrees, so no changes needed.

Example 3 — Left-Heavy Chain

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

› Output: [2,1,3,null,null,null,4]

💡 Note: Original tree is left-heavy chain. After balancing, node 2 becomes root with perfect balance.

Constraints

1 ≤ Number of nodes ≤ 10⁴
1 ≤ Node.val ≤ 10⁴
The input tree is a valid BST

Visualization

Tap to expand

Asked in

a Amazon 45 M Microsoft 38 G Google 32 f Facebook 28

The key insight is to use in-order traversal to extract sorted values, then recursively build a balanced BST by choosing middle elements as roots. Best approach achieves perfect balance in O(n) time and O(n) space.

Common Approaches

✓ Brute Force - Random Reconstruction

⏱️ Time: O(n²) Space: O(n)

Convert the BST to an array, then repeatedly try different construction methods hoping to achieve balance. This approach doesn't guarantee optimal balance and may require multiple attempts.

Optimal - In-order Traversal + Balanced Reconstruction

⏱️ Time: O(n) Space: O(n)

Use in-order traversal to get sorted array of values, then recursively build a balanced BST by always selecting the middle element as root. This guarantees perfect balance in a single pass.

Brute Force - Random Reconstruction — Algorithm Steps

Extract all nodes from BST into array
Try different tree construction approaches
Check if resulting tree is balanced
Repeat until acceptable balance is achieved

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Values

Get all node values from unbalanced BST

Attempt Rebuild

Try different construction methods

Check Balance

Verify if result is acceptably balanced

Code -

solution.c — C

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

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

struct TreeNode* solution(struct TreeNode* root) {
    // Implementation for brute force approach
    return root; // Placeholder
}

int main() {
    printf("[2,1,3]\n"); // Placeholder output
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In-order traversal takes O(n), but multiple reconstruction attempts may be needed

✓ Linear Growth

Space Complexity

O(n)

Array to store all node values plus recursion stack

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

892 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

BST to Balanced BST - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Random Reconstruction — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler