Path Sum Root to Leaf in Binary Tree in DSA Typescript - Execution Trace

Concept Flow - Path Sum Root to Leaf in Binary Tree

Start at root node

↓

Check if node is null?

Yes→Return false

No↓

Check if leaf node?

Yes→Check if sum equals node value

↓

Return true/false

↓

Subtract node value from sum

↓

Recurse left child

↓

Recurse right child

↓

Return left OR right result

Start from root, check if current node is leaf and sum matches. Otherwise, subtract node value and recurse left and right. Return true if any path matches.

Execution Sample

DSA Typescript

function hasPathSum(node, sum) {
  if (!node) return false;
  if (!node.left && !node.right) return sum === node.val;
  return hasPathSum(node.left, sum - node.val) || hasPathSum(node.right, sum - node.val);
}

Checks if there is a root-to-leaf path with the given sum in the binary tree.

Execution Table

Step	Operation	Current Node	Sum Needed	Leaf?	Return Value	Visual State
1	Start at root	5	22	No	N/A	5 / \ 4 8
2	Recurse left	4	17 (22-5)	No	N/A	4 / 11
3	Recurse left	11	13 (17-4)	No	N/A	11 / 7 2
4	Recurse left	7	2 (13-11)	Yes	False	7
5	Recurse right	2	2 (13-11)	Yes	True	2
6	Return from 11	11	13	No	True	11
7	Return from 4	4	17	No	True	4
8	Recurse right	8	17 (22-5)	No	N/A	8 / 13 4
9	Recurse left	13	9 (17-8)	Yes	False	13
10	Recurse right	4	9 (17-8)	Yes	False	4
11	Return from 8	8	17	No	False	8
12	Return from root	5	22	No	True	5

💡 Returned true at leaf node with path sum matching 22

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7	After Step 8	After Step 9	After Step 10	After Step 11	Final
Current Node	5	5	4	11	7	2	11	4	8	13	4	8	5
Sum Needed	22	22	17	13	2	2	13	17	17	9	9	17	22
Return Value	N/A	N/A	N/A	N/A	False	True	True	True	N/A	False	False	False	True

Key Moments - 3 Insights

Why do we check if the node is a leaf before comparing the sum?

Because only root-to-leaf paths count. The check at Step 4 and 5 ensures we only compare sum when at a leaf node, as shown in execution_table rows 4 and 5.

Why do we subtract the node value from sum before recursion?

We reduce the sum needed by the current node's value to check if the remaining path sums to the reduced sum. This is seen in the 'Sum Needed' column changing each step.

What happens if a path returns true early?

The function returns true immediately without checking other paths, as seen at Step 5 returning true and propagating back up in Steps 6 and 7.

Visual Quiz - 3 Questions

Look at the execution_table, what is the sum needed when visiting node 11 at Step 3?

A 13

B 17

C 22

D 2

💡 Hint

Check the 'Sum Needed' column at Step 3 in the execution_table.

At which step does the function first return true?

A Step 4

B Step 5

C Step 6

D Step 7

💡 Hint

Look at the 'Return Value' column in execution_table rows 4 and 5.

If the left subtree of node 4 was missing, what would be the return value at Step 7?

A N/A

B False

C Depends on right subtree

D True

💡 Hint

Step 7 return depends on left and right subtree results as per execution_table logic.

Concept Snapshot

Path Sum Root to Leaf in Binary Tree:
- Start at root node
- If node is leaf, check sum == node.val
- Else subtract node.val from sum
- Recurse left and right
- Return true if any path matches sum
- Stops early if path found

Full Transcript

This concept checks if a binary tree has a root-to-leaf path where the sum of node values equals a target sum. We start at the root and check if the node is null, returning false if so. If the node is a leaf, we compare the remaining sum with the node's value. If they match, we return true. Otherwise, we subtract the node's value from the sum and recursively check the left and right children. The function returns true if any path matches the sum. The execution table shows each step, the current node, the sum needed, whether the node is a leaf, and the return value. The variable tracker shows how the current node and sum needed change at each step. Key moments clarify why leaf checks happen first, why sum is reduced, and how early returns work. The visual quiz tests understanding of sum values at steps, when true is returned, and how missing subtrees affect results.