Construct String from Binary Tree - Practice Coding Problems

Construct String from Binary Tree - Problem

Given the root node of a binary tree, your task is to create a string representation of the tree following a specific set of formatting rules.

The representation should be based on a preorder traversal of the binary tree and must adhere to the following guidelines:

Node Representation: Each node in the tree should be represented by its integer value.

Parentheses for Children: If a node has at least one child (either left or right), its children should be represented inside parentheses. Specifically:

If a node has a left child, the value of the left child should be enclosed in parentheses immediately following the node's value.
If a node has a right child, the value of the right child should also be enclosed in parentheses following the left child.

Omitting Empty Parentheses: Any empty parentheses pairs () should be omitted from the final string representation, with one specific exception: when a node has a right child but no left child, you must include an empty pair of parentheses to indicate the absence of the left child.

This ensures that the one-to-one mapping between the string representation and the original binary tree structure is maintained.

Input & Output

Example 1 — Tree with Mixed Children

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

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

💡 Note: Node 1 has both children. Node 2 has only right child (4), so we include empty parentheses for the missing left child to maintain structure. Node 3 has no children.

Example 2 — Tree with Only Left Children

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

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

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

Example 3 — Single Node

$ Input: root = [1]

› Output: "1"

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

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-1000 ≤ Node.val ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Input Tree

Binary tree with nodes [1,2,3,null,4]

Apply Rules

Add parentheses for children, preserve structure with empty ()

Output String

"1(2()(4))(3)"

Key Takeaway

🎯 Key Insight: Only include empty parentheses when a node has a right child but no left child to maintain unambiguous tree structure

Asked in

a Amazon 35 f Facebook 28 G Google 22

The key insight is to use DFS preorder traversal and carefully handle parentheses: always include empty parentheses when a node has a right child but no left child to preserve the tree structure. Best approach uses direct recursive construction. Time: O(n), Space: O(h)

Common Approaches

Approach	Time	Space	Notes
✓ Optimized DFS	O(n)	O(h)	Direct recursive approach that builds the correct string format during traversal
Recursive DFS with All Parentheses	O(n)	O(h)	Add parentheses for every node with children, then remove unnecessary empty ones

Optimized DFS — Algorithm Steps

Step 1: Start from root and convert value to string
Step 2: If node has children, add left child in parentheses (empty if null)
Step 3: Add right child in parentheses only if it exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Visit Node

Process current node value

Check Children

Add parentheses based on child existence

Recurse

Process children recursively

Code -

solution.c — C

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

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

char* solution(struct TreeNode* root) {
    if (!root) {
        char* result = malloc(1);
        result[0] = '\0';
        return result;
    }
    
    char* result = malloc(10000);
    sprintf(result, "%d", root->val);
    
    if (root->left || root->right) {
        strcat(result, "(");
        if (root->left) {
            char* leftStr = solution(root->left);
            strcat(result, leftStr);
            free(leftStr);
        }
        strcat(result, ")");
        
        if (root->right) {
            strcat(result, "(");
            char* rightStr = solution(root->right);
            strcat(result, rightStr);
            strcat(result, ")");
            free(rightStr);
        }
    }
    
    return result;
}

int main() {
    // For simplicity, create a sample tree
    struct TreeNode* root = malloc(sizeof(struct TreeNode));
    root->val = 1;
    root->left = malloc(sizeof(struct TreeNode));
    root->left->val = 2;
    root->left->left = NULL;
    root->left->right = malloc(sizeof(struct TreeNode));
    root->left->right->val = 4;
    root->left->right->left = NULL;
    root->left->right->right = NULL;
    root->right = malloc(sizeof(struct TreeNode));
    root->right->val = 3;
    root->right->left = NULL;
    root->right->right = NULL;
    
    char* result = solution(root);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during DFS traversal

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

67.0K Views

Medium Frequency

~15 min Avg. Time

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

Optimized DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler