LeetCode #1028 — HARD

Recover a Tree From Preorder Traversal

Break down a hard problem into reliable checkpoints, edge-case handling, and complexity trade-offs.

The Problem

Problem Statement

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 traversal of this traversal, recover the tree and return its root.

Example 1:

Input: traversal = "1-2--3--4-5--6--7"
Output: [1,2,5,3,4,6,7]

Example 2:

Input: traversal = "1-2--3---4-5--6---7"
Output: [1,2,5,3,null,6,null,4,null,7]

Example 3:

Input: traversal = "1-401--349---90--88"
Output: [1,401,null,349,88,90]

Constraints:

The number of nodes in the original tree is in the range [1, 1000].
1 <= Node.val <= 10⁹

Step 01

Brute Force Baseline

Problem summary: 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 traversal of this traversal, recover the tree and return its root.

Baseline thinking

Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.

Pattern signal: Tree

Example 1

"1-2--3--4-5--6--7"

Example 2

"1-2--3---4-5--6---7"

Example 3

"1-401--349---90--88"

Step 02

Core Insight

What unlocks the optimal approach

Do an iterative depth first search, parsing dashes from the string to inform you how to link the nodes together.

Interview move: turn each hint into an invariant you can check after every iteration/recursion step.

Step 03

Algorithm Walkthrough

Iteration Checklist

Define state (indices, window, stack, map, DP cell, or recursion frame).
Apply one transition step and update the invariant.
Record answer candidate when condition is met.
Continue until all input is consumed.

Use the first example testcase as your mental trace to verify each transition.

Step 04

Edge Cases

Minimum Input

Single element / shortest valid input

Validate boundary behavior before entering the main loop or recursion.

Duplicates & Repeats

Repeated values / repeated states

Decide whether duplicates should be merged, skipped, or counted explicitly.

Extreme Constraints

Largest constraint values

Re-check complexity target against constraints to avoid time-limit issues.

Invalid / Corner Shape

Empty collections, zeros, or disconnected structures

Handle special-case structure before the core algorithm path.

Step 05

Full Annotated Code

Source-backed implementations are provided below for direct study and interview prep.

// Accepted solution for LeetCode #1028: Recover a Tree From Preorder Traversal
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode recoverFromPreorder(String traversal) {
        Stack<TreeNode> stack = new Stack<>();
        int i = 0;

        while (i < traversal.length()) {
            int depth = 0;
            while (i < traversal.length() && traversal.charAt(i) == '-') {
                depth++;
                i++;
            }

            int num = 0;
            while (i < traversal.length() && Character.isDigit(traversal.charAt(i))) {
                num = num * 10 + (traversal.charAt(i) - '0');
                i++;
            }

            // Create the new node
            TreeNode newNode = new TreeNode(num);

            while (stack.size() > depth) {
                stack.pop();
            }
            if (!stack.isEmpty()) {
                if (stack.peek().left == null) {
                    stack.peek().left = newNode;
                } else {
                    stack.peek().right = newNode;
                }
            }

            stack.push(newNode);
        }
        return stack.isEmpty() ? null : stack.get(0);
    }
}

// Accepted solution for LeetCode #1028: Recover a Tree From Preorder Traversal
// Auto-generated Go example from java.
func exampleSolution() {
}
// Reference (java):
// // Accepted solution for LeetCode #1028: Recover a Tree From Preorder Traversal
// /**
//  * Definition for a binary tree node.
//  * public class TreeNode {
//  *     int val;
//  *     TreeNode left;
//  *     TreeNode right;
//  *     TreeNode() {}
//  *     TreeNode(int val) { this.val = val; }
//  *     TreeNode(int val, TreeNode left, TreeNode right) {
//  *         this.val = val;
//  *         this.left = left;
//  *         this.right = right;
//  *     }
//  * }
//  */
// class Solution {
//     public TreeNode recoverFromPreorder(String traversal) {
//         Stack<TreeNode> stack = new Stack<>();
//         int i = 0;
// 
//         while (i < traversal.length()) {
//             int depth = 0;
//             while (i < traversal.length() && traversal.charAt(i) == '-') {
//                 depth++;
//                 i++;
//             }
// 
//             int num = 0;
//             while (i < traversal.length() && Character.isDigit(traversal.charAt(i))) {
//                 num = num * 10 + (traversal.charAt(i) - '0');
//                 i++;
//             }
// 
//             // Create the new node
//             TreeNode newNode = new TreeNode(num);
// 
//             while (stack.size() > depth) {
//                 stack.pop();
//             }
//             if (!stack.isEmpty()) {
//                 if (stack.peek().left == null) {
//                     stack.peek().left = newNode;
//                 } else {
//                     stack.peek().right = newNode;
//                 }
//             }
// 
//             stack.push(newNode);
//         }
//         return stack.isEmpty() ? null : stack.get(0);
//     }
// }

# Accepted solution for LeetCode #1028: Recover a Tree From Preorder Traversal
class Solution:
  def recoverFromPreorder(self, traversal: str) -> TreeNode | None:
    i = 0

    def recoverFromPreorder(depth: int) -> TreeNode | None:
      nonlocal i
      nDashes = 0
      while i + nDashes < len(traversal) and traversal[i + nDashes] == '-':
        nDashes += 1
      if nDashes != depth:
        return None

      i += depth
      start = i
      while i < len(traversal) and traversal[i].isdigit():
        i += 1

      return TreeNode(int(traversal[start:i]),
                      recoverFromPreorder(depth + 1),
                      recoverFromPreorder(depth + 1))

    return recoverFromPreorder(0)

// Accepted solution for LeetCode #1028: Recover a Tree From Preorder Traversal
struct Solution;
use rustgym_util::*;
use std::iter::Peekable;
use std::str::Chars;
use std::vec::IntoIter;

enum Tok {
    N(i32),
    D(usize),
}

trait Preorder {
    fn parse(it: &mut Peekable<IntoIter<Tok>>, depth: usize) -> TreeLink;
    fn parse_root(it: &mut Peekable<IntoIter<Tok>>) -> TreeLink;
}

impl Preorder for TreeLink {
    fn parse(it: &mut Peekable<IntoIter<Tok>>, depth: usize) -> TreeLink {
        if let Some(&Tok::D(d)) = it.peek() {
            if d == depth {
                it.next();
                if let Some(Tok::N(n)) = it.next() {
                    TreeLink::branch(n, TreeLink::parse(it, d + 1), TreeLink::parse(it, d + 1))
                } else {
                    None
                }
            } else {
                None
            }
        } else {
            None
        }
    }

    fn parse_root(it: &mut Peekable<IntoIter<Tok>>) -> TreeLink {
        if let Some(Tok::N(n)) = it.next() {
            TreeLink::branch(n, TreeLink::parse(it, 1), TreeLink::parse(it, 1))
        } else {
            None
        }
    }
}

impl Solution {
    fn recover_from_preorder(s: String) -> TreeLink {
        let toks: Vec<Tok> = Self::parse_tokens(&mut s.chars().peekable());
        TreeLink::parse_root(&mut toks.into_iter().peekable())
    }

    fn parse_tokens(it: &mut Peekable<Chars>) -> Vec<Tok> {
        let mut toks: Vec<Tok> = vec![];
        while let Some(c) = it.next() {
            match c {
                '-' => {
                    let mut d = 1;
                    while let Some('-') = it.peek() {
                        it.next();
                        d += 1;
                    }
                    toks.push(Tok::D(d));
                }
                '0'..='9' => {
                    let mut n = (c as u8 - b'0') as i32;
                    while let Some('0'..='9') = it.peek() {
                        n *= 10;
                        n += (it.next().unwrap() as u8 - b'0') as i32;
                    }
                    toks.push(Tok::N(n));
                }
                _ => {}
            }
        }
        toks
    }
}

#[test]
fn test() {
    let s = "1-2--3--4-5--6--7".to_string();
    let res = tree!(
        1,
        tree!(2, tree!(3), tree!(4)),
        tree!(5, tree!(6), tree!(7))
    );
    assert_eq!(Solution::recover_from_preorder(s), res);
    let s = "1-2--3---4-5--6---7".to_string();
    let res = tree!(
        1,
        tree!(2, tree!(3, tree!(4), None), None),
        tree!(5, tree!(6, tree!(7), None), None)
    );
    assert_eq!(Solution::recover_from_preorder(s), res);
    let s = "1-401--349---90--88".to_string();
    let res = tree!(1, tree!(401, tree!(349, tree!(90), None), tree!(88)), None);
    assert_eq!(Solution::recover_from_preorder(s), res);
}

// Accepted solution for LeetCode #1028: Recover a Tree From Preorder Traversal
function recoverFromPreorder(traversal: string): TreeNode | null {
    const stack: TreeNode[] = [];
    let i = 0;

    while (i < traversal.length) {
        let depth = 0;
        while (i < traversal.length && traversal[i] === '-') {
            depth++;
            i++;
        }

        let num = 0;
        while (i < traversal.length && !Number.isNaN(+traversal[i])) {
            num = num * 10 + +traversal[i];
            i++;
        }

        // Create the new node
        const newNode = new TreeNode(num);

        while (stack.length > depth) {
            stack.pop();
        }

        if (stack.length > 0) {
            const i = stack.length - 1;
            if (stack[i].left === null) {
                stack[i].left = newNode;
            } else {
                stack[i].right = newNode;
            }
        }

        stack.push(newNode);
    }

    return stack.length ? stack[0] : null;
}

Step 06

Interactive Study Demo

Use this to step through a reusable interview workflow for this problem.

Custom checkpoints (one per line)

Press Step or Run All to begin.

Step 07

Complexity Analysis

Time

O(n)

Space

O(h)

Approach Breakdown

LEVEL ORDER

O(n) time

O(n) space

BFS with a queue visits every node exactly once — O(n) time. The queue may hold an entire level of the tree, which for a complete binary tree is up to n/2 nodes = O(n) space. This is optimal in time but costly in space for wide trees.

DFS TRAVERSAL

O(n) time

O(h) space

Every node is visited exactly once, giving O(n) time. Space depends on tree shape: O(h) for recursive DFS (stack depth = height h), or O(w) for BFS (queue width = widest level). For balanced trees h = log n; for skewed trees h = n.

Shortcut: Visit every node once → O(n) time. Recursion depth = tree height → O(h) space.

Coach Notes

Common Mistakes

Review these before coding to avoid predictable interview regressions.

Forgetting null/base-case handling

Wrong move: Recursive traversal assumes children always exist.

Usually fails on: Leaf nodes throw errors or create wrong depth/path values.

Fix: Handle null/base cases before recursive transitions.