Construct String from Binary Tree - Practice Coding Problems

Construct String from Binary Tree - Problem

You need to construct a string representation of a binary tree following specific formatting rules based on preorder traversal.

The Rules:

Each node is represented by its integer value
If a node has children, wrap them in parentheses ()
Key rule: Omit empty parentheses () EXCEPT when a node has a right child but no left child - then you MUST include () to show the missing left child

Examples:

Node with left child only: 1(2)
Node with right child only: 1()(3) ← Notice the empty ()
Node with both children: 1(2)(3)

This ensures a unique string representation that can be converted back to the original tree structure.

Input & Output

example_1.py — Basic Tree with Both Children

$ Input: root = [1,2,3,null,4]

› Output: "1(2()(4))(3)"

💡 Note: Node 1 has both children 2 and 3. Node 2 has only right child 4, so we need empty () for missing left child, resulting in ()(4). Node 3 has no children.

example_2.py — Simple Tree

$ Input: root = [1,2,3,4]

› Output: "1(2(4))(3)"

💡 Note: Node 1 has children 2 and 3. Node 2 has only left child 4, so no empty parentheses needed. Node 3 has no children.

example_3.py — Single Node

$ Input: root = [1]

› Output: "1"

💡 Note: Single node with no children requires no parentheses at all.

Visualization

Tap to expand

Understanding the Visualization

Start at Root

Begin with root node value and check for children

Process Left Subtree

Recursively convert left subtree to string

Handle Missing Left Child

Add empty () when right child exists but left doesn't

Process Right Subtree

Convert right subtree if it exists

Combine Results

Assemble final string with proper parentheses

Key Takeaway

🎯 Key Insight: The empty parentheses () act as placeholders to maintain the left-right child order, ensuring the string can be uniquely converted back to the original tree structure.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in the tree

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth equals tree height, plus string storage

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-1000 ≤ Node.val ≤ 1000
Tree is guaranteed to be a valid binary tree

Asked in

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

The optimal approach uses recursive DFS traversal to build the string representation. Key insight: add empty parentheses only when a node has a right child but no left child. This ensures unique string representation that maintains tree structure information.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive DFS with String Building	O(n)	O(n)	Simple recursive approach building string by concatenating at each node

Recursive DFS with String Building — Algorithm Steps

Start from root and add its value to result string
If node has any children, determine what parentheses to add
Recursively process left subtree if it exists
Add empty parentheses if no left child but right child exists
Recursively process right subtree if it exists
Return the concatenated string result

Visualization

Tap to expand

Step-by-Step Walkthrough

Visit Root

Start with root node value

Check Children

Determine if parentheses are needed

Process Left

Recursively build left subtree string

Add Right

Add right subtree if exists

Concatenate

Combine all parts into final string

Code -

solution.c — C

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

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

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

char* tree2str(struct TreeNode* root) {
    if (!root) {
        char* empty = malloc(1);
        empty[0] = '\0';
        return empty;
    }
    
    char* result = malloc(10000);
    int pos = 0;
    dfs(root, result, &pos);
    result[pos] = '\0';
    return result;
}

int main() {
    printf("Implementation ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in the tree

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth equals tree height, plus string storage

⚡ Linearithmic Space

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-1000 ≤ Node.val ≤ 1000
Tree is guaranteed to be a valid binary tree

67.9K Views

Medium Frequency

~15 min Avg. Time

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

Recursive DFS with String Building — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler