Convert Sorted List to Binary Search Tree

Convert Sorted List to Binary Search Tree - Problem

Given the head of a singly linked list where 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.

The resulting BST should maintain the sorted order property where for each node:

All values in the left subtree are less than the node's value
All values in the right subtree are greater than the node's value

Input & Output

Example 1 — Basic Conversion

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

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

💡 Note: One possible balanced BST: root=0, left subtree has -3 with -10 as left child, right subtree has 9 with 5 as left child

Example 2 — Empty List

$ Input: head = []

› Output: []

💡 Note: Empty linked list results in null tree

Example 3 — Single Node

$ Input: head = [1]

› Output: [1]

💡 Note: Single node becomes the root with no children

Constraints

0 ≤ Number of nodes ≤ 2 × 10⁴
-10⁵ ≤ Node.val ≤ 10⁵
The linked list is sorted in ascending order

Visualization

Tap to expand

Asked in

f Facebook 15 a Amazon 12 M Microsoft 8 G Google 6

The key insight is to use the middle element as root for height balance. The optimal approach uses inorder simulation to build the tree directly without extra space. Time: O(n), Space: O(log n)

Common Approaches

✓ Convert to Array First

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

First traverse the linked list to collect all values into an array, then recursively build a height-balanced BST by always choosing the middle element as root.

Two-Pointer Inorder Simulation

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

Simulate inorder traversal while building the tree. Use two pointers to find the middle of current segment, make it root, then recursively build left and right subtrees without extra space.

Convert to Array First — Algorithm Steps

Step 1: Traverse linked list and store values in array
Step 2: Recursively build BST using middle element as root
Step 3: Left half becomes left subtree, right half becomes right subtree

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Values

Traverse linked list and collect values into array

Find Middle

Choose middle element as root for balance

Build Tree

Recursively build left and right subtrees

Code -

solution.c — C

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

struct ListNode {
    int val;
    struct ListNode* next;
};

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

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

struct TreeNode* solution(struct ListNode* head) {
    if (!head) return NULL;
    
    static int values[20000];
    int count = 0;
    struct ListNode* current = head;
    while (current) {
        values[count++] = current->val;
        current = current->next;
    }
    
    return buildBST(values, 0, count - 1);
}

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

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    struct ListNode* head = NULL;
    struct ListNode* current = NULL;
    
    if (strlen(line) > 2 && strcmp(line, "[]") != 0) {
        char* p = line + 1; // Skip '['
        while (*p && *p != ']') {
            while (*p == ' ' || *p == ',') p++;
            if (*p == ']' || *p == '\0') break;
            
            int val = (int)strtol(p, &p, 10);
            struct ListNode* node = malloc(sizeof(struct ListNode));
            node->val = val;
            node->next = NULL;
            
            if (!head) {
                head = current = node;
            } else {
                current->next = node;
                current = node;
            }
        }
    }
    
    struct TreeNode* result = solution(head);
    printTree(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) to traverse list + O(n) to build tree = O(n) total

✓ Linear Growth

Space Complexity

O(n)

Array stores all n values + O(log n) recursion stack

⚡ Linearithmic Space

125.0K Views

Medium Frequency

~25 min Avg. Time

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

Convert to Array First — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler