Path Sum Root to Leaf in Binary Tree in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of path sum check for a simple tree

What is the output of the following TypeScript code that checks if a path sum exists from root to leaf?

DSA Typescript

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val === undefined ? 0 : val;
    this.left = left === undefined ? null : left;
    this.right = right === undefined ? null : right;
  }
}

function hasPathSum(root: TreeNode | null, targetSum: number): boolean {
  if (!root) return false;
  if (!root.left && !root.right) return root.val === targetSum;
  return hasPathSum(root.left, targetSum - root.val) || hasPathSum(root.right, targetSum - root.val);
}

const tree = new TreeNode(5, new TreeNode(4, new TreeNode(11, new TreeNode(7), new TreeNode(2)), null), new TreeNode(8, new TreeNode(13), new TreeNode(4, null, new TreeNode(1))));
console.log(hasPathSum(tree, 22));

A true

B false

C SyntaxError

D TypeError

💡 Hint

Think about whether there is a root-to-leaf path that sums to 22.

The tree has a path 5 -> 4 -> 11 -> 2 which sums to 22, so the function returns true.

❓ Predict Output

intermediate

Output when no path matches the target sum

What will be printed when the following code runs?

DSA Typescript

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val === undefined ? 0 : val;
    this.left = left === undefined ? null : left;
    this.right = right === undefined ? null : right;
  }
}

function hasPathSum(root: TreeNode | null, targetSum: number): boolean {
  if (!root) return false;
  if (!root.left && !root.right) return root.val === targetSum;
  return hasPathSum(root.left, targetSum - root.val) || hasPathSum(root.right, targetSum - root.val);
}

const tree = new TreeNode(1, new TreeNode(2), new TreeNode(3));
console.log(hasPathSum(tree, 5));

A false

B true

C undefined

D RuntimeError

💡 Hint

Check if any root-to-leaf path sums to 5.

Paths are 1->2 (sum 3) and 1->3 (sum 4), neither equals 5, so output is false.

🔧 Debug

advanced

Identify the error in path sum function

What error will this code produce when run?

DSA Typescript

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val === undefined ? 0 : val;
    this.left = left === undefined ? null : left;
    this.right = right === undefined ? null : right;
  }
}

function hasPathSum(root: TreeNode | null, targetSum: number): boolean {
  if (!root) return false;
  if (!root.left && !root.right) return root.val === targetSum;
  return hasPathSum(root.left, targetSum - root.val) && hasPathSum(root.right, targetSum - root.val);
}

const tree = new TreeNode(1, new TreeNode(2), new TreeNode(3));
console.log(hasPathSum(tree, 3));

A StackOverflowError

B false

C true

D TypeError

💡 Hint

Check the logical operator used in the recursive call.

The code uses '&&' which requires both left and right paths to have the sum, but only one path needs to match. So it returns false.

❓ Predict Output

advanced

Output of path sum with negative values

What is the output of this code that includes negative values in the tree?

DSA Typescript

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val === undefined ? 0 : val;
    this.left = left === undefined ? null : left;
    this.right = right === undefined ? null : right;
  }
}

function hasPathSum(root: TreeNode | null, targetSum: number): boolean {
  if (!root) return false;
  if (!root.left && !root.right) return root.val === targetSum;
  return hasPathSum(root.left, targetSum - root.val) || hasPathSum(root.right, targetSum - root.val);
}

const tree = new TreeNode(-2, null, new TreeNode(-3));
console.log(hasPathSum(tree, -5));

A SyntaxError

B false

C true

D TypeError

💡 Hint

Consider the path -2 -> -3 and its sum.

The path -2 -> -3 sums to -5, so the function returns true.

🧠 Conceptual

expert

Number of root-to-leaf paths with given sum

Given a binary tree, how many root-to-leaf paths sum to the target value 8 in the tree below? Tree structure: 5 / \ 4 8 / / \ 11 13 4 / \ \ 7 2 1 Options:

A 2

B 3

C 1

D 0

💡 Hint

Find all root-to-leaf paths and sum their values.

No root-to-leaf paths sum to 8. The path sums are: 5+4+11+7=27, 5+4+11+2=22, 5+8+13=26, 5+8+4+1=18. None equal 8.