Count Total Nodes in Binary Tree in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to return the total number of nodes in the binary tree.

DSA Typescript

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

Drag options to blanks, or click blank then click option'

A1

B0

Cnull

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Returning 1 instead of 0 for null nodes.

Returning null which causes errors.

When the node is null, it means no node exists, so count is 0.

2fill in blank

medium

Complete the code to check if the current node is null before counting.

DSA Typescript

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

Drag options to blanks, or click blank then click option'

Anull

Broot.left

Croot.right

Droot

Attempts:

3 left

💡 Hint

Common Mistakes

Checking left or right child instead of the current node.

Checking against a wrong variable.

We check if the current node root is null to stop recursion.

3fill in blank

hard

Fix the error in the recursive call to count left subtree nodes.

DSA Typescript

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

Drag options to blanks, or click blank then click option'

Aroot.right

Bnull

Croot.left

Droot

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the whole root again causing infinite recursion.

Passing right child instead of left child.

To count left subtree nodes, we call countNodes(root.left).

4fill in blank

hard

Fill both blanks to complete the function that counts nodes using recursion.

DSA Typescript

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

Drag options to blanks, or click blank then click option'

Aroot

Broot.left

Croot.right

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Checking left or right child instead of root for null.

Passing wrong child node in recursive call.

The base case checks if root is null, then recursively count left subtree with root.left.

5fill in blank

hard

Fill all three blanks to complete the recursive function counting all nodes in the binary tree.

DSA Typescript

function countNodes(root: TreeNode | null): number {
  if ([1] === null) return 0;
  return 1 + countNodes([2]) + countNodes([3]);
}

Drag options to blanks, or click blank then click option'

Aroot

Broot.left

Croot.right

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Using null instead of root for base case.

Mixing left and right child nodes in recursive calls.

Check if root is null, then count nodes in left subtree root.left and right subtree root.right.

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