Count Total Nodes in Binary Tree in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

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

DSA C++

int countNodes(Node* root) {
    if (root == nullptr) {
        return 0;
    }
    return 1 + countNodes(root->[1]) + countNodes(root->right);
}

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

Aright

Bleft

Cparent

Dchild

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'right' instead of 'left' for the left subtree.

Trying to access a non-existent 'parent' pointer.

The function counts nodes by adding 1 for the current node plus the counts of nodes in the left and right subtrees. The left subtree is accessed by root->left.

2fill in blank

medium

Complete the code to correctly check if the tree is empty.

DSA C++

int countNodes(Node* root) {
    if ([1] == nullptr) {
        return 0;
    }
    return 1 + countNodes(root->left) + countNodes(root->right);
}

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

Aroot->left

Broot->right

Croot

Dnullptr

Attempts:

3 left

💡 Hint

Common Mistakes

Checking left or right child instead of root.

Comparing to a variable instead of nullptr.

To check if the tree is empty, we check if the root pointer itself is nullptr.

3fill in blank

hard

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

DSA C++

int countNodes(Node* root) {
    if (root == nullptr) {
        return 0;
    }
    return 1 + countNodes(root->left) + countNodes(root->[1]);
}

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

Aright

Bparent

Cchild

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'parent' or 'next' which do not exist in the node structure.

Using 'child' which is not a pointer name.

The right subtree is accessed by root->right. Using any other pointer name will cause an error or wrong result.

4fill in blank

hard

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

DSA C++

int countNodes(Node* root) {
    if (root == [1]) {
        return 0;
    }
    return 1 + countNodes(root->[2]) + countNodes(root->right);
}

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

Anullptr

Broot

Cleft

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'root' instead of 'nullptr' in base case.

Using 'right' instead of 'left' for left subtree.

The base case checks if root == nullptr to stop recursion. The left subtree is accessed by root->left.

5fill in blank

hard

Fill all three blanks to complete the recursive node counting function correctly.

DSA C++

int countNodes(Node* root) {
    if (root == [1]) {
        return 0;
    }
    return 1 + countNodes(root->[2]) + countNodes(root->[3]);
}

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

Anullptr

Bleft

Cright

Dparent

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'parent' which does not exist in node structure.

Mixing up left and right pointers.

The base case checks if root == nullptr. The left and right subtrees are accessed by root->left and root->right respectively.

Practice

1. What does the function countNodes do in a binary tree?

easy

A. Checks if the binary tree is balanced

B. Finds the height of the binary tree

C. Calculates the sum of all node values

D. Counts the total number of nodes in the binary tree

Solution

1. Step 1: Understand the function purpose

   The function countNodes is designed to traverse the binary tree and count every node it visits.

2. Step 2: Differentiate from other tree functions

   Unlike functions that find height, sum values, or check balance, this function specifically returns the total count of nodes.

3. Final Answer:

   Counts the total number of nodes in the binary tree -> Option D

4. Quick Check:

   Counting nodes = total nodes [OK]

Hint: Count nodes by visiting each once [OK]

Common Mistakes:

• Confusing node count with tree height
• Thinking it sums node values
• Assuming it checks tree balance

2. Which of the following is the correct base case for a recursive function counting nodes in a binary tree?

easy

A. if (root == nullptr) return 0;

B. if (root == nullptr) return 1;

C. if (root == nullptr) return -1;

D. if (root == nullptr) return root->data;

Solution

1. Step 1: Identify base case for recursion

   When the current node is null (no node), the count should be zero because there is no node to count.

2. Step 2: Check each option

   if (root == nullptr) return 0; returns 0 for null nodes, which is correct. Other options return incorrect values for base case.

3. Final Answer:

   if (root == nullptr) return 0; -> Option A

4. Quick Check:

   Null node count = 0 [OK]

Hint: Return 0 when node is null [OK]

Common Mistakes:

• Returning 1 for null node
• Returning node data in base case
• Returning negative values

3. What is the output of the following code snippet?

struct Node {
  int data;
  Node* left;
  Node* right;
};

int countNodes(Node* root) {
  if (root == nullptr) return 0;
  return 1 + countNodes(root->left) + countNodes(root->right);
}

int main() {
  Node n1 = {1, nullptr, nullptr};
  Node n2 = {2, nullptr, nullptr};
  Node n3 = {3, &n1, &n2};
  std::cout << countNodes(&n3);
  return 0;
}

medium

A. 1

B. 2

C. 3

D. 0

Solution

1. Step 1: Analyze the tree structure

   Node n3 is root with left child n1 and right child n2. Both n1 and n2 have no children.

2. Step 2: Count nodes recursively

   countNodes(n3) = 1 + countNodes(n1) + countNodes(n2) = 1 + 1 + 1 = 3

3. Final Answer:

   3 -> Option C

4. Quick Check:

   3 nodes counted [OK]

Hint: Add 1 for current node plus children counts [OK]

Common Mistakes:

• Counting only root node
• Ignoring one child subtree
• Returning zero for non-null root

4. Find the error in this code snippet for counting nodes in a binary tree:

int countNodes(Node* root) {
  if (root == nullptr) return 0;
  return countNodes(root->left) + countNodes(root->right);
}

medium

A. Missing addition of 1 for current node

B. Base case returns 1 instead of 0

C. Function does not handle nullptr correctly

D. No error, code is correct

Solution

1. Step 1: Check base case correctness

   Base case returns 0 for nullptr, which is correct.

2. Step 2: Check counting logic

   The function sums counts of left and right subtrees but does not add 1 for the current node itself, missing counting the root.

3. Final Answer:

   Missing addition of 1 for current node -> Option A

4. Quick Check:

   Count must include current node [OK]

Hint: Add 1 for current node in return [OK]

Common Mistakes:

• Returning 1 for null node
• Not adding 1 for current node
• Confusing base case return value

5. Given a binary tree where each node has either 0 or 2 children, and the total number of leaf nodes is 7, what is the total number of nodes in the tree?

hard

A. 14

B. 13

C. 15

D. 16

Solution

1. Step 1: Recall property of full binary trees

   In a full binary tree (nodes have 0 or 2 children), total nodes = 2 * leaf nodes - 1.

2. Step 2: Calculate total nodes

   Given leaf nodes = 7, total nodes = 2 * 7 - 1 = 13.

3. Step 3: Verify formula and options

   Formula: total nodes = 2 * leaf nodes - 1 = 2*7 -1 = 13, which matches 13.

4. Final Answer:

   13 -> Option B

5. Quick Check:

   Full binary tree nodes = 2*leaves - 1 [OK]

Hint: Use full tree formula: nodes = 2*leaves - 1 [OK]

Common Mistakes:

• Using wrong formula for total nodes
• Confusing leaf nodes with total nodes
• Selecting option without calculation