Balance a Binary Search Tree

Balance a Binary Search Tree - Problem

Given the root of a binary search tree, return a balanced binary search tree with the same node values. If there is more than one answer, return any of them.

A binary search tree is balanced if the depth of the two subtrees of every node never differs by more than 1.

Input & Output

Example 1 — Right Skewed Tree

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

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

💡 Note: Original tree is completely right-skewed. After balancing, node 2 becomes root with 1 as left child and 3 as right child, with 4 as right child of 3.

Example 2 — Left Skewed Tree

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

› Output: [2,1,3]

💡 Note: Tree is already balanced - depth difference between left and right subtrees is at most 1, so no changes needed.

Example 3 — Complex Unbalanced

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

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

💡 Note: Completely unbalanced chain becomes balanced with 3 as root, 2 on left (with 1 as left child), and 4 on right (with 5 as right child).

Constraints

The number of nodes in the tree is in the range [1, 10⁴].
1 ≤ Node.val ≤ 10⁵

Visualization

Tap to expand

Asked in

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

The key insight is to use the BST property: inorder traversal gives sorted values. Extract sorted array via DFS, then use divide and conquer to build balanced tree by always choosing middle element as root. Best approach is DFS + Divide and Conquer. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force Reconstruction

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

Generate all possible BST configurations with the same values and test each one for balance property. This involves creating every permutation of tree structures.

DFS Inorder + Divide and Conquer

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

First perform inorder traversal to get sorted values, then use divide and conquer to build a balanced BST by always choosing the middle element as root.

Brute Force Reconstruction — Algorithm Steps

Step 1: Extract all values from the BST
Step 2: Generate all possible BST structures
Step 3: Check each structure for balance property

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Values

Get all node values from original tree

Generate All BSTs

Create every possible BST arrangement

Check Balance

Test each tree for balance property

Code -

solution.c — C

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

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

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

TreeNode* parseTree(const char* arrStr) {
    int len = strlen(arrStr);
    char* str = (char*)malloc(len + 1);
    strcpy(str, arrStr);
    
    // Remove whitespace and brackets
    char* start = str;
    while (*start && (*start == ' ' || *start == '[')) start++;
    char* end = start + strlen(start) - 1;
    while (end > start && (*end == ' ' || *end == ']' || *end == '\n')) end--;
    *(end + 1) = '\0';
    
    if (strlen(start) == 0) {
        free(str);
        return NULL;
    }
    
    // Parse tokens
    static char tokens[10000][20];
    int tokenCount = 0;
    char* token = strtok(start, ",");
    while (token && tokenCount < 10000) {
        // Remove whitespace
        while (*token == ' ') token++;
        char* end_token = token + strlen(token) - 1;
        while (end_token > token && *end_token == ' ') end_token--;
        *(end_token + 1) = '\0';
        
        strcpy(tokens[tokenCount], token);
        tokenCount++;
        token = strtok(NULL, ",");
    }
    
    if (tokenCount == 0 || strcmp(tokens[0], "null") == 0) {
        free(str);
        return NULL;
    }
    
    TreeNode* root = createNode(atoi(tokens[0]));
    static TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < tokenCount) {
        TreeNode* node = queue[front++];
        
        // Left child
        if (i < tokenCount && strcmp(tokens[i], "null") != 0) {
            node->left = createNode(atoi(tokens[i]));
            queue[rear++] = node->left;
        }
        i++;
        
        // Right child
        if (i < tokenCount && strcmp(tokens[i], "null") != 0) {
            node->right = createNode(atoi(tokens[i]));
            queue[rear++] = node->right;
        }
        i++;
    }
    
    free(str);
    return root;
}

void inorder(TreeNode* node, int* result, int* size) {
    if (node) {
        inorder(node->left, result, size);
        result[(*size)++] = node->val;
        inorder(node->right, result, size);
    }
}

TreeNode* buildBalanced(int* vals, int left, int right) {
    if (left > right) {
        return NULL;
    }
    
    int mid = left + (right - left) / 2;
    TreeNode* root = createNode(vals[mid]);
    
    root->left = buildBalanced(vals, left, mid - 1);
    root->right = buildBalanced(vals, mid + 1, right);
    
    return root;
}

TreeNode* balanceBST(TreeNode* root) {
    if (!root) {
        return NULL;
    }
    
    static int sortedVals[10000];
    int size = 0;
    inorder(root, sortedVals, &size);
    
    return buildBalanced(sortedVals, 0, size - 1);
}

void printTree(TreeNode* root) {
    if (!root) {
        printf("[]\n");
        return;
    }
    
    static TreeNode* queue[10000];
    static int result[10000];
    static int isNull[10000];
    int front = 0, rear = 0, resultSize = 0;
    
    queue[rear++] = root;
    
    while (front < rear) {
        TreeNode* node = queue[front++];
        
        if (node) {
            result[resultSize] = node->val;
            isNull[resultSize] = 0;
            resultSize++;
            queue[rear++] = node->left;
            queue[rear++] = node->right;
        } else {
            isNull[resultSize] = 1;
            resultSize++;
        }
    }
    
    // Remove trailing nulls
    while (resultSize > 0 && isNull[resultSize - 1]) {
        resultSize--;
    }
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) printf(", ");
        if (isNull[i]) {
            printf("null");
        } else {
            printf("%d", result[i]);
        }
    }
    printf("]\n");
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    TreeNode* root = parseTree(input);
    TreeNode* balanced = balanceBST(root);
    printTree(balanced);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Generating all possible BST structures takes factorial time, and checking balance takes O(n)

✓ Linear Growth

Space Complexity

O(n)

Storage for generated trees and recursion stack

⚡ Linearithmic Space

98.4K Views

Medium Frequency

~25 min Avg. Time

2.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Reconstruction — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler