Construct Binary Tree from String

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.

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

Visualization

Tap to expand

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

✓ Math

⏱️ Time: N/A Space: N/A

Greedy

⏱️ Time: N/A Space: N/A

Recursive Parsing (Optimized)

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

This approach uses recursion with a global index to parse the string in one pass. It processes each character sequentially, building the tree structure as it encounters numbers and parentheses. The key insight is to use an index pointer that advances through the string, eliminating the need for substring operations.

Algorithm Steps — Algorithm Steps

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;
}

void toString(TreeNode* node, char* result, int* pos) {
    if (!node) return;
    
    char valStr[20];
    sprintf(valStr, "%d", node->val);
    strcpy(result + *pos, valStr);
    *pos += strlen(valStr);
    
    if (node->left || node->right) {
        result[(*pos)++] = '(';
        if (node->left) {
            toString(node->left, result, pos);
        }
        result[(*pos)++] = ')';
        if (node->right) {
            result[(*pos)++] = '(';
            toString(node->right, result, pos);
            result[(*pos)++] = ')';
        }
    }
}

static int index_global;

TreeNode* parseTree(const char* s, int len) {
    if (index_global >= len) return NULL;
    
    // Parse number (could be negative)
    int start = index_global;
    if (s[index_global] == '-') {
        index_global++;
    }
    while (index_global < len && isdigit(s[index_global])) {
        index_global++;
    }
    
    char numStr[20];
    strncpy(numStr, s + start, index_global - start);
    numStr[index_global - start] = '\0';
    int val = atoi(numStr);
    
    TreeNode* node = createNode(val);
    
    // Check for children
    if (index_global < len && s[index_global] == '(') {
        // Parse left child
        index_global++; // skip '('
        if (index_global < len && s[index_global] == ')') {
            // Empty left child
            node->left = NULL;
            index_global++; // skip ')'
        } else {
            node->left = parseTree(s, len);
            index_global++; // skip ')'
        }
        
        // Parse right child if exists
        if (index_global < len && s[index_global] == '(') {
            index_global++; // skip '('
            if (index_global < len && s[index_global] == ')') {
                // Empty right child
                node->right = NULL;
                index_global++; // skip ')'
            } else {
                node->right = parseTree(s, len);
                index_global++; // skip ')'
            }
        }
    }
    
    return node;
}

TreeNode* solution(const char* s) {
    if (!s || strlen(s) == 0) return NULL;
    index_global = 0;
    return parseTree(s, strlen(s));
}

int main() {
    static char s[30005];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline
    int len = strlen(s);
    if (len > 0 && s[len-1] == '\n') {
        s[len-1] = '\0';
    }
    
    TreeNode* result = solution(s);
    if (result) {
        static char output[100000];
        int pos = 0;
        toString(result, output, &pos);
        output[pos] = '\0';
        printf("%s\n", output);
    } else {
        printf("\n");
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

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