Recover a Tree From Preorder Traversal

Recover a Tree From Preorder Traversal - Problem

We run a preorder depth-first search (DFS) on the root of a binary tree. At each node in this traversal, we output D dashes (where D is the depth of this node), then we output the value of this node.

If the depth of a node is D, the depth of its immediate child is D + 1. The depth of the root node is 0.

If a node has only one child, that child is guaranteed to be the left child.

Given the output of this traversal, recover the tree and return its root.

Input & Output

Example 1 — Basic Tree

$ Input: traversal = "1-2--3--4-5"

› Output: [1,2,5,3,4,null,null]

💡 Note: Root 1 has children 2 and 5. Node 2 has children 3 and 4. The dashes indicate depth: 1 (depth 0), 2 (depth 1), 3 (depth 2), 4 (depth 2), 5 (depth 1).

Example 2 — Single Path

$ Input: traversal = "1-2--3---4"

› Output: [1,2,null,3,null,4]

💡 Note: Each node has only a left child, creating a left-skewed tree. Node 1 → 2 → 3 → 4 in a single path.

Example 3 — Single Node

$ Input: traversal = "1"

› Output: [1]

💡 Note: Only root node with value 1, no children.

Constraints

The number of nodes in the original tree is in the range [1, 1000]
1 ≤ Node.val ≤ 10⁹
The depth of any node is at most 1000

Visualization

Tap to expand

Asked in

f Facebook 25 G Google 20 a Amazon 15

The key insight is to use a stack to maintain the path from root to current node, where stack depth corresponds to tree depth. The optimal approach parses the traversal string once to extract (depth, value) pairs, then uses a stack to track potential parent nodes. Time: O(n), Space: O(h) where h is tree height.

Common Approaches

✓ Recursive Parsing with String Manipulation

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

For each position in the traversal string, count the number of dashes to determine depth, extract the value, then recursively process the remaining string to find children. This approach uses string slicing and multiple passes through the data.

Stack-Based Iterative Construction

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

Parse the traversal string character by character, using a stack to keep track of potential parent nodes. When we encounter a node at depth d, we pop the stack until we find the correct parent at depth d-1, then add the new node as its child.

Recursive Parsing with String Manipulation — Algorithm Steps

Count dashes at current position to find depth
Extract node value after dashes
Recursively find left and right children from remaining string
Return constructed node

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Dashes

Determine node depth from dash count

Extract Value

Parse numeric value after dashes

Recursive Build

Recursively process children at deeper levels

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* solution(char* traversal) {
    if (!traversal || strlen(traversal) == 0) {
        return NULL;
    }
    
    // Parse the traversal string into (depth, value) pairs
    int nodes[1000][2]; // [depth, value] pairs
    int nodeCount = 0;
    
    int i = 0;
    int len = strlen(traversal);
    
    while (i < len) {
        int depth = 0;
        while (i < len && traversal[i] == '-') {
            depth++;
            i++;
        }
        
        // Parse the number
        int start = i;
        int isNegative = 0;
        if (i < len && traversal[i] == '-') {
            // Handle negative number
            isNegative = 1;
            i++;
        }
        while (i < len && isdigit(traversal[i])) {
            i++;
        }
        
        // Extract value
        int val = 0;
        for (int j = start + isNegative; j < i; j++) {
            val = val * 10 + (traversal[j] - '0');
        }
        if (isNegative) {
            val = -val;
        }
        
        nodes[nodeCount][0] = depth;
        nodes[nodeCount][1] = val;
        nodeCount++;
    }
    
    // Build tree using stack
    struct TreeNode* stack[1000];
    int stackSize = 0;
    
    for (int idx = 0; idx < nodeCount; idx++) {
        int depth = nodes[idx][0];
        int val = nodes[idx][1];
        
        struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
        node->val = val;
        node->left = NULL;
        node->right = NULL;
        
        // Pop stack until we find the correct parent
        while (stackSize > depth) {
            stackSize--;
        }
        
        // If we have a parent, attach this node
        if (stackSize > 0) {
            struct TreeNode* parent = stack[stackSize - 1];
            if (parent->left == NULL) {
                parent->left = node;
            } else {
                parent->right = node;
            }
        }
        
        stack[stackSize++] = node;
    }
    
    return stackSize > 0 ? stack[0] : NULL;
}

void printTreeArray(struct TreeNode* root) {
    if (!root) {
        printf("[]\n");
        return;
    }
    
    struct TreeNode* queue[2000];
    int front = 0, rear = 0;
    int values[2000];
    int count = 0;
    
    queue[rear++] = root;
    
    while (front < rear) {
        struct TreeNode* node = queue[front++];
        
        if (node) {
            values[count++] = node->val;
            queue[rear++] = node->left;
            queue[rear++] = node->right;
        } else {
            values[count++] = -1000001; // Use special value to represent null
        }
    }
    
    // Remove trailing None values (Python's exact logic)
    while (count > 0 && values[count - 1] == -1000001) {
        count--;
    }
    
    printf("[");
    for (int i = 0; i < count; i++) {
        if (i > 0) printf(",");
        if (values[i] == -1000001) {
            printf("null");
        } else {
            printf("%d", values[i]);
        }
    }
    printf("]\n");
}

int main() {
    char traversal[10000];
    fgets(traversal, sizeof(traversal), stdin);
    traversal[strcspn(traversal, "\n")] = 0;
    
    struct TreeNode* result = solution(traversal);
    printTreeArray(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

String operations and recursive calls with substring processing

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth up to n nodes plus string copies

✓ Linear Space

67.0K Views

Medium Frequency

~25 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

Constraints

Visualization

Related Problems

Common Approaches

Recursive Parsing with String Manipulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler