Maximum Path Sum in Binary Tree in DSA Javascript - Execution Trace

Concept Flow - Maximum Path Sum in Binary Tree

Start at root node

↓

Calculate max path sum from left subtree

↓

Calculate max path sum from right subtree

↓

Calculate max path including current node

↓

Update global max if current path sum is higher

↓

Return max path sum for one side + current node

↓

Repeat for all nodes

↓

Final max path sum stored globally

We visit each node, calculate max path sums from left and right children, update global max path sum including current node, and return max sum for one side to parent.

Execution Sample

DSA Javascript

function maxPathSum(root) {
  let maxSum = -Infinity;
  function dfs(node) {
    if (!node) return 0;
    let left = Math.max(dfs(node.left), 0);
    let right = Math.max(dfs(node.right), 0);
    maxSum = Math.max(maxSum, left + right + node.val);
    return Math.max(left, right) + node.val;
  }
  dfs(root);
  return maxSum;
}

This code finds the maximum path sum in a binary tree by recursively calculating max sums from children and updating a global max.

Execution Table

Step	Operation	Node Visited	Left Max	Right Max	Current Max Path	Global Max	Return Value	Visual State
1	Visit node	10	N/A	N/A	N/A	-Infinity	N/A	10
2	Visit node	2	N/A	N/A	N/A	-Infinity	N/A	2
3	Calculate left max	2	0	0	2	2	2	10 -> 2
4	Visit node	10	2	N/A	N/A	2	N/A	10
5	Visit node	10	2	10	N/A	2	N/A	10 -> 2, 10
6	Calculate max path	10	2	10	22	22	20	10 -> 2, 10
7	Visit node	-25	N/A	N/A	N/A	22	N/A	10 -> 2, 10
8	Visit node	3	N/A	N/A	N/A	22	N/A	10 -> 2, 10
9	Calculate left max	3	0	0	3	22	3	10 -> 2, 10
10	Visit node	-25	3	N/A	N/A	22	N/A	10 -> 2, 10
11	Visit node	4	N/A	N/A	N/A	22	N/A	10 -> 2, 10
12	Calculate right max	-25	3	4	-18	22	-18	10 -> 2, 10
13	Calculate max path	-25	3	4	-18	22	-18	10 -> 2, 10
14	Return to parent	-25	3	4	-18	22	-18	10 -> 2, 10
15	Calculate max path	10	2	10	22	22	20	10 -> 2, 10
16	Update global max	10	2	10	22	22	20	10 -> 2, 10
17	Return to root	10	2	10	22	22	20	10 -> 2, 10
18	Final max path sum	root	N/A	N/A	N/A	22	N/A	10 -> 2, 10

💡 All nodes visited, global max path sum is 22

Variable Tracker

Variable	Start	After Step 3	After Step 9	After Step 12	After Step 16	Final
maxSum	-Infinity	2	22	22	22	22
left	N/A	0	0	3	2	2
right	N/A	0	0	4	10	10
returnValue	N/A	2	3	-18	20	20

Key Moments - 3 Insights

Why do we use Math.max(dfs(node.left), 0) instead of just dfs(node.left)?

Because negative path sums reduce the total, we ignore them by taking max with 0. See execution_table rows 3 and 9 where left or right max is 0 instead of negative.

Why do we update global max with left + right + node.val?

Because the max path can pass through the current node connecting left and right subtrees. This is shown in execution_table row 6 where global max is updated with sum including both sides.

What does the return value of dfs represent?

It represents the max path sum for one side plus current node to be used by parent. It never includes both sides to avoid double counting. See returnValue column in execution_table.

Visual Quiz - 3 Questions

Look at the execution_table at step 6, what is the global max path sum?

A 10

B 12

C 22

D -Infinity

💡 Hint

Check the Global Max column at step 6 in execution_table

At which step does the left max path sum for node with value 3 get calculated?

A Step 9

B Step 3

C Step 12

D Step 16

💡 Hint

Look at the Left Max column and Node Visited column in execution_table

If we remove Math.max(..., 0) and allow negative sums, how would the global max change?

A It would stay the same

B It could decrease because negative paths reduce sums

C It would always increase

D It would cause an error

💡 Hint

Refer to key_moments about ignoring negative sums and execution_table rows where 0 replaces negatives

Concept Snapshot

Maximum Path Sum in Binary Tree:
- Visit each node recursively
- Calculate max path sum from left and right children (ignore negatives)
- Update global max with left + right + node value
- Return max path sum for one side + node value
- Final global max is answer

Full Transcript

This visualization shows how to find the maximum path sum in a binary tree. We start at the root and recursively visit each node. For each node, we calculate the maximum path sum from its left and right children, ignoring negative sums by taking the maximum with zero. We then update a global maximum path sum if the sum of left max, right max, and the current node's value is greater than the current global max. The function returns the maximum path sum for one side plus the current node's value to its parent. This process repeats for all nodes, and the final global max is the maximum path sum in the tree.