Convert Sorted Array to Binary Search Tree

Convert Sorted Array to Binary Search Tree - Problem

Given an integer array nums where the elements are sorted in ascending order, convert it to a height-balanced binary search tree.

A height-balanced binary tree is a binary tree in which the depth of the two subtrees of every node never differs by more than 1.

Input & Output

Example 1 — Basic Case

$ Input: nums = [-10,-3,0,5,9]

› Output: [0,-3,9,-10,null,5]

💡 Note: Middle element 0 becomes root. Left subtree from [-10,-3] has root -3 with left child -10. Right subtree from [5,9] has root 9 with left child 5.

Example 2 — Even Length Array

$ Input: nums = [1,3]

› Output: [1,null,3]

💡 Note: For even length, we pick left middle (index 0). Element 1 becomes root with right child 3.

Example 3 — Single Element

$ Input: nums = [0]

› Output: [0]

💡 Note: Single element becomes the root with no children.

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁴ ≤ nums[i] ≤ 10⁴
nums is sorted in strictly increasing order

Visualization

Tap to expand

Asked in

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

The key insight is to use divide and conquer: pick the middle element as root to ensure balance. The optimal approach recursively builds left and right subtrees from the corresponding halves. Time: O(n), Space: O(log n).

Common Approaches

✓ Divide and Conquer (Optimal)

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

Use the middle element of each subarray as the root. Recursively build left subtree from left half and right subtree from right half. This ensures perfect balance.

Sequential Construction

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

Insert each array element sequentially into a BST. Since array is sorted, this creates a completely unbalanced tree (like a linked list).

Divide and Conquer (Optimal) — Algorithm Steps

Find middle element of current array/subarray
Make it the root of current subtree
Recursively build left subtree from left half
Recursively build right subtree from right half

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick Middle

Choose middle element as root

Divide

Split array into left and right halves

Conquer

Recursively build left and right subtrees

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* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

struct TreeNode* buildTree(int* nums, int left, int right) {
    if (left > right) return NULL;
    
    // Choose right middle for even length arrays
    int mid = (left + right + 1) / 2;
    struct TreeNode* root = createNode(nums[mid]);
    root->left = buildTree(nums, left, mid - 1);
    root->right = buildTree(nums, mid + 1, right);
    return root;
}

struct TreeNode* solution(int* nums, int numsSize) {
    if (numsSize == 0) return NULL;
    return buildTree(nums, 0, numsSize - 1);
}

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

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[10000];
    int numsSize = 0;
    
    // Parse input manually
    char* start = strchr(line, '[');
    if (start) {
        start++; // Skip '['
        char* end = strchr(start, ']');
        if (end) {
            *end = '\0'; // Null terminate
            
            if (strlen(start) > 0) {
                char* ptr = start;
                while (*ptr && numsSize < 10000) {
                    // Skip whitespace and commas
                    while (*ptr == ' ' || *ptr == ',') ptr++;
                    if (*ptr == '\0') break;
                    
                    // Parse number
                    char* endptr;
                    nums[numsSize++] = (int)strtol(ptr, &endptr, 10);
                    ptr = endptr;
                }
            }
        }
    }
    
    struct TreeNode* result = solution(nums, numsSize);
    printTreeArray(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each element exactly once to create corresponding tree node

⚠ Quadratic Growth

Space Complexity

O(log n)

Recursion stack depth is O(log n) for balanced tree, plus O(n) for tree storage

⚡ Linearithmic Space

311.5K Views

Medium Frequency

~15 min Avg. Time

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

Divide and Conquer (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler