Count Total Nodes in Binary Tree in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Node Count in Simple Binary Tree

What is the output of the following TypeScript code that counts total nodes in a binary tree?

DSA Typescript

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

function countNodes(root: TreeNode | null): number {
  if (root === null) return 0;
  return 1 + countNodes(root.left) + countNodes(root.right);
}

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

A 0

B 2

C 1

D 3

💡 Hint

Count the root node plus nodes in left and right subtrees.

The tree has root node 1, left child 2, and right child 3, total 3 nodes.

❓ Predict Output

intermediate

Count Nodes in Unbalanced Binary Tree

What will be printed after running this code that counts nodes in an unbalanced binary tree?

DSA Typescript

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

function countNodes(root: TreeNode | null): number {
  if (root === null) return 0;
  return 1 + countNodes(root.left) + countNodes(root.right);
}

const tree = new TreeNode(10, new TreeNode(5, new TreeNode(3)), null);
console.log(countNodes(tree));

A 1

B 3

C 2

D 0

💡 Hint

Count all nodes including left subtree nodes.

The tree has nodes 10, 5, and 3, total 3 nodes.

🔧 Debug

advanced

Identify the Error in Node Counting Function

What error will this TypeScript code produce when counting nodes in a binary tree?

DSA Typescript

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

function countNodes(root: TreeNode | null): number {
  if (root === null) return 0;
  return 1 + countNodes(root.left) - countNodes(root.right);
}

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

A SyntaxError

B 2

C 1

D 0

💡 Hint

Check the operator used between recursive calls.

The code subtracts right subtree count instead of adding: 1 + 1 - 1 = 1 (logical error, outputs 1 instead of 3).

❓ Predict Output

advanced

Count Nodes in Large Balanced Binary Tree

What is the output of this code counting nodes in a balanced binary tree of height 3?

DSA Typescript

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

function countNodes(root: TreeNode | null): number {
  if (root === null) return 0;
  return 1 + countNodes(root.left) + countNodes(root.right);
}

const tree = new TreeNode(1,
  new TreeNode(2, new TreeNode(4), new TreeNode(5)),
  new TreeNode(3, new TreeNode(6), new TreeNode(7))
);
console.log(countNodes(tree));

A 7

B 6

C 8

D 5

💡 Hint

Count all nodes in a full binary tree with 3 levels.

A full binary tree with height 3 has 7 nodes total.

🧠 Conceptual

expert

Time Complexity of Counting Nodes in Binary Tree

What is the time complexity of the recursive function that counts total nodes in a binary tree with n nodes?

A O(n)

B O(log n)

C O(n log n)

D O(1)

💡 Hint

Consider how many nodes the function visits.

The function visits each node once, so time complexity is linear O(n).

Practice

1. What does the function to count total nodes in a binary tree return when the tree is empty?

easy

A. -1

B. 1

C. 0

D. null

Solution

1. Step 1: Understand the base case for an empty tree

   When the binary tree is empty, there are no nodes to count, so the count should be zero.

2. Step 2: Confirm the function's return value for empty input

   The function should return 0 to indicate no nodes exist in the tree.

3. Final Answer:

   0 -> Option C

4. Quick Check:

   Empty tree node count = 0 [OK]

Hint: Empty tree always has zero nodes [OK]

Common Mistakes:

• Returning 1 for empty tree
• Returning null instead of 0
• Confusing empty tree with leaf node

2. Which of the following TypeScript function signatures correctly defines a function to count total nodes in a binary tree node structure?

easy

A. function countNodes(root: number): number

B. function countNodes(root: any): string

C. function countNodes(root: TreeNode): void

D. function countNodes(root: TreeNode | null): number

Solution

1. Step 1: Identify correct parameter type for binary tree root

   The root should be a TreeNode or null if the tree is empty.

2. Step 2: Confirm return type for count function

   The function returns a number representing total nodes, so return type must be number.

3. Final Answer:

   function countNodes(root: TreeNode | null): number -> Option D

4. Quick Check:

   Correct parameter and return types = function countNodes(root: TreeNode | null): number [OK]

Hint: Function must accept node or null and return number [OK]

Common Mistakes:

• Using wrong parameter type
• Returning void instead of number
• Returning string instead of number

3. Given the following binary tree code, what is the output of console.log(countNodes(root));?

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

function countNodes(root: TreeNode | null): number {
  if (!root) return 0;
  return 1 + countNodes(root.left) + countNodes(root.right);
}

const root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.left = new TreeNode(4);
root.left.right = new TreeNode(5);

medium

A. 5

B. 6

C. 4

D. 3

Solution

1. Step 1: Count nodes in the tree structure

   The tree has nodes: 1 (root), 2 and 3 (children), 4 and 5 (children of 2). Total nodes = 5.

2. Step 2: Verify recursive count function output

   The function counts 1 for root plus counts of left and right subtrees, summing to 5.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   Total nodes counted = 5 [OK]

Hint: Count all nodes including root and children [OK]

Common Mistakes:

• Counting only leaf nodes
• Missing one subtree
• Off-by-one error in count

4. Identify the error in the following TypeScript function to count total nodes in a binary tree:

function countNodes(root: TreeNode | null): number {
  if (root === null) return 1;
  return 1 + countNodes(root.left) + countNodes(root.right);
}

medium

A. Function does not count the current node

B. Base case returns 1 instead of 0 for null

C. Missing return type annotation

D. Incorrect parameter type

Solution

1. Step 1: Check base case return value

   The base case returns 1 when root is null, which incorrectly counts non-existent nodes.

2. Step 2: Understand correct base case for counting nodes

   For null nodes, the count should be 0, not 1, to avoid overcounting.

3. Final Answer:

   Base case returns 1 instead of 0 for null -> Option B

4. Quick Check:

   Base case must return 0 for null [OK]

Hint: Base case for null must return 0 nodes [OK]

Common Mistakes:

• Returning 1 for null node
• Not counting current node
• Wrong parameter or return types

5. You want to count total nodes in a binary tree but only count nodes with even values. Which modification to the standard count function is correct?

function countEvenNodes(root: TreeNode | null): number {
  if (!root) return 0;
  const leftCount = countEvenNodes(root.left);
  const rightCount = countEvenNodes(root.right);
  // What to add here?
}

hard

A. return (root.val % 2 === 0 ? 1 : 0) + leftCount + rightCount;

B. return 1 + leftCount + rightCount;

C. return leftCount + rightCount;

D. return (root.val % 2 !== 0 ? 1 : 0) + leftCount + rightCount;

Solution

1. Step 1: Check node value for evenness

   Use modulo operator to check if root.val is even; if yes, count 1, else 0.

2. Step 2: Sum counts from left, right, and current node if even

   Add leftCount, rightCount, and 1 or 0 based on current node's evenness.

3. Final Answer:

   return (root.val % 2 === 0 ? 1 : 0) + leftCount + rightCount; -> Option A

4. Quick Check:

   Count only even nodes correctly [OK]

Hint: Add 1 only if node value is even [OK]

Common Mistakes:

• Counting all nodes regardless of value
• Counting odd nodes instead
• Forgetting to add left and right counts