Binary Tree Paths

Binary Tree Paths - Problem

Given the root of a binary tree, return all root-to-leaf paths in any order.

A leaf is a node with no children.

Input & Output

Example 1 — Basic Binary Tree

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

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

💡 Note: Tree has two root-to-leaf paths: 1→2→5 (left subtree) and 1→3 (right subtree)

Example 2 — Single Node Tree

$ Input: root = [1]

› Output: ["1"]

💡 Note: Tree with only root node - the single path is just the root value

Example 3 — Complete Binary Tree

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

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

💡 Note: Three root-to-leaf paths: left-left (1→2→4), left-right (1→2→5), and right (1→3)

Constraints

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

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 a Amazon 32 Apple 28

The key insight is to use DFS traversal to explore all paths from root to leaves. The optimal approach uses DFS with backtracking and path list maintenance. Time: O(n), Space: O(h)

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Path List and Backtracking	O(n)	O(h)	Use DFS with a path list, adding/removing nodes during traversal
Brute Force DFS with String Building	O(n²)	O(n²)	Build path strings by concatenating values during DFS traversal

DFS with Path List and Backtracking — Algorithm Steps

Start DFS with empty path list
Add current node to path
If leaf, convert path to string and add to results
Recursively explore children
Backtrack by removing current node from path

Visualization

Tap to expand

Step-by-Step Walkthrough

Add to Path

Add current node to path list

Check Leaf

If leaf, convert path to string and save

Backtrack

Remove current node and try next branch

Code -

solution.c — C

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

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

char** result;
int resultSize;
int resultCapacity;
int* path;
int pathSize;
int pathCapacity;

void dfs(struct TreeNode* node) {
    if (!node) return;
    
    if (pathSize >= pathCapacity) {
        pathCapacity *= 2;
        path = realloc(path, pathCapacity * sizeof(int));
    }
    path[pathSize++] = node->val;
    
    if (!node->left && !node->right) {
        char pathStr[1000] = "";
        for (int i = 0; i < pathSize; i++) {
            if (i > 0) strcat(pathStr, "->");
            char valStr[20];
            sprintf(valStr, "%d", path[i]);
            strcat(pathStr, valStr);
        }
        
        if (resultSize >= resultCapacity) {
            resultCapacity *= 2;
            result = realloc(result, resultCapacity * sizeof(char*));
        }
        result[resultSize] = malloc(strlen(pathStr) + 1);
        strcpy(result[resultSize], pathStr);
        resultSize++;
    } else {
        dfs(node->left);
        dfs(node->right);
    }
    
    pathSize--;
}

char** solution(struct TreeNode* root, int* returnSize) {
    result = malloc(1000 * sizeof(char*));
    resultSize = 0;
    resultCapacity = 1000;
    path = malloc(1000 * sizeof(int));
    pathSize = 0;
    pathCapacity = 1000;
    
    if (!root) {
        *returnSize = 0;
        return result;
    }
    
    dfs(root);
    *returnSize = resultSize;
    return result;
}

int main() {
    // For simplicity, create a test tree manually
    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 = 5;
    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;
    
    int returnSize;
    char** paths = solution(root, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", paths[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once, path operations are O(1) amortized

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth O(h) plus current path storage O(h) where h is tree height

✓ Linear Space

285.0K Views

Medium Frequency

~15 min Avg. Time

4.2K 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 Path List and Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler