Path Sum

Path Sum - Problem

Imagine you're a treasure hunter navigating through a binary tree where each node represents a checkpoint with a specific value. Your mission is to find if there exists a path from the root (starting point) to any leaf (dead end) where the sum of all values along that path equals your target treasure value.

Given the root of a binary tree and an integer targetSum, return true if the tree has a root-to-leaf path such that adding up all the values along the path equals targetSum.

Remember: A leaf is a node with no children - it's where your treasure hunt must end!

Input & Output

example_1.py — Basic Path Sum

$ Input: root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22

› Output: true

💡 Note: The root-to-leaf path with target sum 22 is shown: 5 + 4 + 11 + 2 = 22

example_2.py — No Valid Path

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

› Output: false

💡 Note: There are two root-to-leaf paths: (1 + 2 = 3) and (1 + 3 = 4). Neither equals the target sum of 5.

example_3.py — Empty Tree

$ Input: root = [], targetSum = 0

› Output: false

💡 Note: Since the tree is empty, there are no root-to-leaf paths, so return false.

Constraints

The number of nodes in the tree is in the range [0, 5000]
Node values are in the range [-1000, 1000]
-1000 ≤ targetSum ≤ 1000
A leaf is a node with no children

Visualization

Tap to expand

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 28

The optimal solution uses recursive DFS to traverse the tree while maintaining a running sum. At each node, we subtract the current value from the target sum and recursively check subtrees. When we reach a leaf, we check if the remaining sum equals the leaf's value. This approach requires O(n) time and O(h) space where h is the tree height.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive DFS (Optimal)	O(n)	O(h)	Traverse tree with running sum, subtract values as we go deeper

Recursive DFS (Optimal) — Algorithm Steps

Start DFS from root with the original targetSum
At each node, subtract current node value from remaining sum
If we reach a leaf node, check if remaining sum equals 0
If leaf has sum 0, return true; otherwise continue searching
Recursively check both left and right subtrees

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Begin with original targetSum

Subtract Current Value

Update remaining sum at each node

Check at Leaves

If remaining sum equals current leaf value, path found

Code -

solution.c — C

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

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

bool hasPathSum(struct TreeNode* root, int targetSum) {
    // Base case: empty tree
    if (!root) {
        return false;
    }
    
    // If we're at a leaf node, check if remaining sum equals leaf's value
    if (!root->left && !root->right) {
        return root->val == targetSum;
    }
    
    // Recursively check left and right subtrees with updated target
    int remainingSum = targetSum - root->val;
    return hasPathSum(root->left, remainingSum) || 
           hasPathSum(root->right, remainingSum);
}

// Helper function to create a new tree node
struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

int main() {
    // Example usage - create a sample tree
    struct TreeNode* root = createNode(5);
    root->left = createNode(4);
    root->right = createNode(8);
    root->left->left = createNode(11);
    root->left->left->left = createNode(7);
    root->left->left->right = createNode(2);
    root->right->left = createNode(13);
    root->right->right = createNode(4);
    root->right->right->right = createNode(1);
    
    int targetSum = 22;
    bool result = hasPathSum(root, targetSum);
    printf("%s\n", result ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once in the worst case

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, which is O(log n) for balanced trees, O(n) for skewed trees

✓ Linear Space

58.0K Views

High Frequency

~15 min Avg. Time

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

Recursive DFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler