Count Total Nodes in Binary Tree in DSA C++ - Time & Space Complexity

Time Complexity: Count Total Nodes in Binary Tree

O(n)

Understanding Time Complexity

We want to understand how the time needed to count all nodes in a binary tree changes as the tree grows.

How does the work increase when the tree has more nodes?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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

This code counts all nodes by visiting each node once, adding 1 for the current node plus counts from left and right subtrees.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Recursive calls visiting each node once.
• How many times: Once per node in the tree.

How Execution Grows With Input

Each node is visited exactly once, so the work grows directly with the number of nodes.

Input Size (n)	Approx. Operations
10	About 10 visits
100	About 100 visits
1000	About 1000 visits

Pattern observation: The time grows linearly as the number of nodes increases.

Final Time Complexity

Time Complexity: O(n)

This means the time to count nodes grows directly with the number of nodes in the tree.

Common Mistake

[X] Wrong: "Counting nodes is faster because it just adds 1 without looping much."

[OK] Correct: Even though adding 1 is simple, the function must visit every node to count it, so the total work depends on the tree size.

Interview Connect

Understanding this helps you explain how recursive tree traversals work and why visiting all nodes takes time proportional to the tree size.

Self-Check

"What if the tree was a balanced binary search tree? Would the time complexity to count nodes change?"

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