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

Goal: Transform a sorted array into a balanced BST where all left descendants are smaller and all right descendants are larger than the parent node.

Example: Array [1, 3, 5, 7, 9] should become a BST with root 5, left subtree containing [1, 3], and right subtree containing [7, 9].

Input & Output

example_1.py — Basic Case

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

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

💡 Note: The middle element 0 becomes root. Left subtree is built from [-10,-3] with -3 as root and -10 as left child. Right subtree is built from [5,9] with 9 as root and 5 as left child.

example_2.py — Single Element

$ Input: nums = [1]

› Output: [1]

💡 Note: Array with single element creates a tree with just the root node containing that element.

example_3.py — Even Length Array

$ Input: nums = [1,3]

› Output: [3,1] or [1,null,3]

💡 Note: For even length arrays, we can choose either middle element (index 0 or 1). Both create valid height-balanced BSTs.

Visualization

Tap to expand

Understanding the Visualization

Find the Middle Manager

Choose the employee with median experience as the department head

Organize Left Team

Recursively organize less experienced employees under left management

Organize Right Team

Recursively organize more experienced employees under right management

Balanced Structure

Result is an efficient hierarchy with minimal communication overhead

Key Takeaway

🎯 Key Insight: The middle element of a sorted array is the perfect choice for a balanced BST root, as it naturally divides the remaining elements into two equal halves, recursively creating optimal balance.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each insertion takes O(height) time, and height grows to n, so total is O(n²)

⚠ Quadratic Growth

Space Complexity

O(n)

Space for n tree nodes, plus O(n) recursion stack in worst case

⚡ Linearithmic Space

Constraints

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

Asked in

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

The optimal approach uses divide and conquer strategy: always choose the middle element as root, then recursively build left and right subtrees from the remaining subarrays. This creates a perfectly balanced BST with O(log n) height in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Sequential Insertion)	O(n²)	O(n)	Insert elements sequentially into BST, resulting in skewed tree
Divide and Conquer (Optimal)	O(n)	O(log n)	Always choose middle element as root, recursively build left and right subtrees

Brute Force (Sequential Insertion) — Algorithm Steps

Start with empty BST
Insert first element as root
Insert remaining elements sequentially
Each insertion goes to the right child since array is sorted

Visualization

Tap to expand

Step-by-Step Walkthrough

Insert 1

First element becomes root

Insert 3

Goes to right since 3 > 1

Insert 5

Goes to right of 3 since 5 > 3

Result

Tree resembles a linked list

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.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* insert(struct TreeNode* root, int val) {
    if (!root) return createNode(val);
    if (val < root->val) {
        root->left = insert(root->left, val);
    } else {
        root->right = insert(root->right, val);
    }
    return root;
}

struct TreeNode* sortedArrayToBST(int* nums, int numsSize) {
    if (numsSize == 0) return NULL;
    
    struct TreeNode* root = createNode(nums[0]);
    for (int i = 1; i < numsSize; i++) {
        insert(root, nums[i]);
    }
    
    return root;
}

int main() {
    printf("Tree created (skewed structure)\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each insertion takes O(height) time, and height grows to n, so total is O(n²)

⚠ Quadratic Growth

Space Complexity

O(n)

Space for n tree nodes, plus O(n) recursion stack in worst case

⚡ Linearithmic Space

Constraints

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

89.5K Views

High Frequency

~15 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Sequential Insertion) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler