Construct Binary Tree from String - Practice Coding Problems

Construct Binary Tree from String - Problem

Construct Binary Tree from String

Imagine you have a serialized representation of a binary tree encoded as a string using parentheses notation - similar to how mathematical expressions are written! Your task is to deserialize this string back into the original binary tree structure.

The string format follows these rules:
• Each node value is an integer
• Left and right children are enclosed in parentheses ()
• If a node has children, the left child always comes first
• Empty parentheses () represent null nodes

Examples:
• "4(2(3)(1))(6(5))" represents a tree with root 4, left subtree 2 with children 3 and 1, and right subtree 6 with left child 5
• "4(2()(1))" has root 4, left child 2 where 2 has no left child but has right child 1

Your goal is to parse this string and construct the corresponding binary tree, returning the root node.

Input & Output

example_1.py — Basic Tree Construction

$ Input: s = "4(2(3)(1))(6(5))"

› Output: Tree with root 4, left subtree 2 with children 3 and 1, right subtree 6 with left child 5

💡 Note: The string represents a complete binary tree. Root is 4, left child is 2 (which has left child 3 and right child 1), right child is 6 (which has left child 5 and no right child).

example_2.py — Tree with Missing Left Child

$ Input: s = "4(2()(1))(6(5))"

› Output: Tree where node 2 has no left child but has right child 1

💡 Note: The empty parentheses () indicate a missing left child. Node 2 has null as left child and 1 as right child, while maintaining the same structure elsewhere.

example_3.py — Single Node Tree

$ Input: s = "-4"

› Output: Tree with single node containing value -4

💡 Note: A simple case with just one node containing a negative number. No parentheses means no children, so it's just a root node with value -4.

Visualization

Tap to expand

Understanding the Visualization

Start with Root

Parse the first number (4) as the root of our tree

Enter Left Subtree

First '(' indicates left child - recursively build subtree 2(3)(1)

Build Nested Structure

Continue recursively: node 2 gets left child 3 and right child 1

Process Right Subtree

After closing left subtree, build right subtree 6(5)

Complete Tree

Final tree has all nodes connected according to parentheses structure

Key Takeaway

🎯 Key Insight: The parentheses structure directly maps to tree relationships - each opening parenthesis starts a subtree, and recursive parsing with a global index eliminates the need for expensive string operations

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character in the string is processed exactly once

✓ Linear Growth

Space Complexity

O(n)

Recursion depth equals tree height, which can be O(n) in worst case

⚡ Linearithmic Space

Constraints

0 ≤ s.length ≤ 3 × 10⁴
s consists of digits, '(', ')', and '-' only
Node values can be negative integers
Input string represents a valid binary tree structure

Asked in

G Google 35 f Facebook 28 a Amazon 22 ⊞ Microsoft 18

The optimal approach uses recursive parsing with index tracking to construct the binary tree in O(n) time. The key insight is to maintain a global index that advances through the string, parsing node values and using parentheses to guide the recursive construction of left and right subtrees. This eliminates the need for expensive substring operations while naturally handling the tree structure through recursion depth.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Parsing (Optimized)	O(n)	O(n)	Use recursion with index tracking to parse the string efficiently

Recursive Parsing (Optimized) — Algorithm Steps

Use a global index to track current position in string
Parse the current node value at the index position
If next character is '(', recursively build left child
If another '(' follows, recursively build right child
Skip closing ')' and return the constructed node

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Root

Index at 0, parse '4' and create root node

Process '('

Index at 1, enter left subtree recursion

Parse Children

Recursively parse '2(3)(1)' maintaining index

Continue Right

Index advances to parse '6(5)' subtree

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.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;
}

int index_global;

struct TreeNode* helper(char* s, int len) {
    if (index_global >= len) {
        return NULL;
    }
    
    // Parse the number
    int start = index_global;
    if (s[index_global] == '-') {
        index_global++;
    }
    while (index_global < len && isdigit(s[index_global])) {
        index_global++;
    }
    
    char temp = s[index_global];
    s[index_global] = '\0';
    int val = atoi(s + start);
    s[index_global] = temp;
    
    struct TreeNode* node = createNode(val);
    
    // Check for left child
    if (index_global < len && s[index_global] == '(') {
        index_global++; // Skip '('
        node->left = helper(s, len);
        index_global++; // Skip ')'
        
        // Check for right child
        if (index_global < len && s[index_global] == '(') {
            index_global++; // Skip '('
            node->right = helper(s, len);
            index_global++; // Skip ')'
        }
    }
    
    return node;
}

struct TreeNode* str2tree(char* s) {
    if (!s || strlen(s) == 0) {
        return NULL;
    }
    
    index_global = 0;
    return helper(s, strlen(s));
}

void serialize(struct TreeNode* root, char* result, int* pos) {
    if (!root) {
        strcpy(result + *pos, "null");
        *pos += 4;
        return;
    }
    
    char val_str[20];
    sprintf(val_str, "%d", root->val);
    strcpy(result + *pos, val_str);
    *pos += strlen(val_str);
    
    if (root->left || root->right) {
        result[*pos] = '(';
        (*pos)++;
        serialize(root->left, result, pos);
        result[*pos] = ')';
        (*pos)++;
        
        if (root->right) {
            result[*pos] = '(';
            (*pos)++;
            serialize(root->right, result, pos);
            result[*pos] = ')';
            (*pos)++;
        }
    }
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
    }
    if (s[strlen(s) - 1] == '"') {
        s[strlen(s) - 1] = '\0';
    }
    
    struct TreeNode* result = str2tree(s);
    
    char output[2000] = {0};
    int pos = 0;
    serialize(result, output, &pos);
    
    printf("%s\n", output);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character in the string is processed exactly once

✓ Linear Growth

Space Complexity

O(n)

Recursion depth equals tree height, which can be O(n) in worst case

⚡ Linearithmic Space

Constraints

0 ≤ s.length ≤ 3 × 10⁴
s consists of digits, '(', ')', and '-' only
Node values can be negative integers
Input string represents a valid binary tree structure

42.0K Views

Medium Frequency

~15 min Avg. Time

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

Recursive Parsing (Optimized) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler