Codestin Search App

Binary Tree Paths - Problem

Binary Tree Paths is a fundamental tree traversal problem that asks you to find all possible routes from the root to every leaf node. Given the root of a binary tree, your task is to return all root-to-leaf paths in any order. A leaf is defined as a node that has no children (both left and right children are null). Goal: Collect every unique path from root to leaf as a string representation. Input: Root node of a binary tree Output: Array of strings, where each string represents a path from root to leaf For example, if you have a tree with root value 1, left child 2, and right child 3, the paths would be ["1->2", "1->3"] (assuming 2 and 3 are leaf nodes).

Input & Output

example_1.py — Basic Binary Tree

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

› Output: ["1->2->5","1->3"]

💡 Note: Tree has two paths from root to leaves: 1->2->5 (left path through node 2 to leaf 5) and 1->3 (right path directly to leaf 3)

example_2.py — Single Node Tree

$ Input: root = [1]

› Output: ["1"]

💡 Note: Tree contains only the root node, which is also a leaf. The single path is just the root value.

example_3.py — Linear Tree

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

› Output: ["1->2->3->4"]

💡 Note: Tree forms a linear chain going left at each level. Only one path exists from root 1 to the single leaf 4.

Constraints

The number of nodes in the tree is in the range [0, 100]
Node values are in the range [-100, 100]
All node values are unique
Tree can be empty (root = null)

Visualization

Tap to expand

Understanding the Visualization

Start Exploration

Begin at the family patriarch/matriarch (root node)

Follow Lineages

Trace down each branch, recording names along the way

Record Complete Lines

When reaching someone with no children (leaf), save the full lineage

Backtrack

Return to previous generation and explore other branches

Key Takeaway

🎯 Key Insight: DFS with backtracking builds paths incrementally in one traversal, making it optimal for tree path discovery problems.

Asked in

G Google 45 f Facebook 38 A Amazon 42 ⊞ Microsoft 35

The optimal approach uses DFS with backtracking to build paths incrementally. Start from root, add each node to current path, save complete paths at leaves, then backtrack by removing nodes. This achieves O(n) time complexity with single tree traversal and clean recursive implementation.

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Backtracking (Optimal)	O(n)	O(h)	Build paths incrementally during DFS traversal with backtracking

DFS with Backtracking (Optimal) — Algorithm Steps

Start DFS from root with an empty path
Add current node to the path
If current node is a leaf, add path to result
Recursively explore left and right subtrees
Backtrack by removing current node from path

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin at root with empty path

Build Path

Add nodes to path as we traverse down

Record Leaf Paths

When reaching leaves, save complete path

Backtrack

Remove nodes from path when returning up

Code -

solution.c — C

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

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

char** binaryTreePaths(struct TreeNode* root, int* returnSize) {
    *returnSize = 0;
    if (!root) return NULL;
    
    char** result = (char**)malloc(1000 * sizeof(char*));
    
    void dfs(struct TreeNode* node, char* path, int pathLen) {
        if (!node) return;
        
        char nodeStr[20];
        sprintf(nodeStr, "%d", node->val);
        
        // Build current path
        char currentPath[1000];
        strcpy(currentPath, path);
        if (pathLen > 0) {
            strcat(currentPath, "->");
        }
        strcat(currentPath, nodeStr);
        
        // If leaf node, add to result
        if (!node->left && !node->right) {
            result[*returnSize] = (char*)malloc(strlen(currentPath) + 1);
            strcpy(result[*returnSize], currentPath);
            (*returnSize)++;
        } else {
            // Continue exploring children
            dfs(node->left, currentPath, pathLen + 1);
            dfs(node->right, currentPath, pathLen + 1);
        }
    }
    
    dfs(root, "", 0);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal visiting each node exactly once

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height, plus space for current path

✓ Linear Space

89.6K Views

High Frequency

~15 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

DFS with Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler