Count Total Nodes in Binary Tree in DSA C#

Mental Model

We want to find how many nodes are in a tree by visiting each node once and counting it.

Analogy: Imagine counting all the people in a family tree by visiting each person and adding one to your count.

    1
   / \
  2   3
 / 
4  

Dry Run Walkthrough

Input: Binary tree: 1 with left child 2 and right child 3; 2 has left child 4

Goal: Count all nodes in the tree

Step 1: Start at root node 1, count 1

Visited: 1

Why: We begin counting from the root node

Step 2: Move to left child 2, count 1 more

Visited: 1 -> 2

Why: We count the left subtree nodes

Step 3: Move to left child of 2, node 4, count 1 more

Visited: 1 -> 2 -> 4

Why: We count the left subtree of node 2

Step 4: Node 4 has no children, return count 1

Back to node 2

Why: Leaf node counted, go back to parent

Step 5: Node 2 has no right child, total count at 2 is 1 (node 2) + 1 (node 4) = 2

Back to node 1

Why: Sum counts from left and right subtrees plus current node

Step 6: Move to right child 3, count 1 more

Visited: 1 -> 3

Why: Count right subtree nodes

Step 7: Node 3 has no children, return count 1

Back to node 1

Why: Leaf node counted, go back to root

Step 8: Total count at root 1 is 1 (root) + 2 (left subtree) + 1 (right subtree) = 4

Final count = 4

Why: Sum all counts to get total nodes

Result:

1 -> 2 -> 4 -> 3 -> null
Total nodes: 4

Annotated Code

DSA C#

using System;

class Node
{
    public int data;
    public Node left, right;
    public Node(int item)
    {
        data = item;
        left = right = null;
    }
}

class BinaryTree
{
    public Node root;

    // Count total nodes in binary tree
    public int CountNodes(Node node)
    {
        if (node == null)
            return 0; // base case: no node here

        // count current node + left subtree + right subtree
        return 1 + CountNodes(node.left) + CountNodes(node.right);
    }

    static void Main(string[] args)
    {
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(4);

        int totalNodes = tree.CountNodes(tree.root);
        Console.WriteLine("1 -> 2 -> 4 -> 3 -> null");
        Console.WriteLine("Total nodes: " + totalNodes);
    }
}

if (node == null) return 0; // base case: no node here

stop counting when no node exists (leaf child)

return 1 + CountNodes(node.left) + CountNodes(node.right);

count current node plus counts from left and right subtrees

Output

1 -> 2 -> 4 -> 3 -> null

Total nodes: 4

Complexity Analysis

Time: O(n) because we visit each of the n nodes exactly once

Space: O(h) where h is the height of the tree due to recursion stack

vs Alternative: This is more efficient than iterative counting with extra data structures because it uses simple recursion and no extra memory for node storage

Edge Cases

Empty tree (root is null)

Returns 0 because there are no nodes

DSA C#

if (node == null)
    return 0;

Single node tree

Returns 1 because only root exists

DSA C#

return 1 + CountNodes(node.left) + CountNodes(node.right);

Tree with only left or only right children

Counts all nodes correctly by recursive calls

DSA C#

return 1 + CountNodes(node.left) + CountNodes(node.right);

When to Use This Pattern

When you need to find the size of a tree or count elements in a hierarchical structure, use recursive counting because it naturally explores all nodes.

Common Mistakes

Mistake: Forgetting to return 0 for null nodes causing errors or infinite recursion
Fix: Add base case: if node is null, return 0 immediately

Mistake: Counting only current node without adding counts from children
Fix: Return 1 plus counts from left and right subtrees

Summary

Counts all nodes in a binary tree by visiting each node once.

Use when you need to know how many nodes are in a tree structure.

The key is to count current node plus counts from left and right children recursively.

Practice

1. What does the function to count total nodes in a binary tree do?

easy

A. Counts only the leaf nodes

B. Counts nodes only on the left subtree

C. Counts only the root node

D. Counts all nodes including root, left, and right children

Solution

1. Step 1: Understand the node counting concept

   The function counts every node in the tree, including root and all children.

2. Step 2: Differentiate from partial counts

   Counting only leaves or root ignores other nodes, so total count includes all nodes.

3. Final Answer:

   Counts all nodes including root, left, and right children -> Option D

4. Quick Check:

   Total nodes = all nodes in tree [OK]

Hint: Count every node visited in tree traversal [OK]

Common Mistakes:

• Counting only leaf nodes
• Ignoring root node
• Counting only one subtree

2. Which of the following is the correct C# syntax to define a binary tree node class for counting nodes?

easy

A. public class Node { public int data; public Node left, right; }

B. class Node { int data; Node left, right; void count() {} }

C. public struct Node { int data; Node left; Node right; }

D. class Node { public int data; public Node left; private Node right; }

Solution

1. Step 1: Check class and member access

   public class Node { public int data; public Node left, right; } correctly defines a public class with public members for data and child nodes.

2. Step 2: Verify syntax correctness

   class Node { int data; Node left, right; void count() {} } misses access modifiers and method is irrelevant; C uses struct which is less common; D has private right node which restricts access.

3. Final Answer:

   public class Node { public int data; public Node left, right; } -> Option A

4. Quick Check:

   Correct class with public members [OK]

Hint: Use public class with public node references [OK]

Common Mistakes:

• Missing public keyword
• Using struct instead of class
• Private child nodes blocking access

3. What is the output of the following C# code that counts nodes in a binary tree?

class Node {
  public int data;
  public Node left, right;
  public Node(int val) { data = val; left = right = null; }
}

int CountNodes(Node root) {
  if (root == null) return 0;
  return 1 + CountNodes(root.left) + CountNodes(root.right);
}

// Tree:
//     1
//    / \
//   2   3
//  / 
// 4

Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);

Console.WriteLine(CountNodes(root));

medium

A. 4

B. 3

C. 5

D. 6

Solution

1. Step 1: Count nodes in the tree structure

   The tree has nodes: 1 (root), 2 (left child), 3 (right child), and 4 (left child of 2), total 4 nodes.

2. Step 2: Apply recursive count function

   CountNodes returns 1 + left subtree count + right subtree count, summing to 4.

3. Final Answer:

   4 -> Option A

4. Quick Check:

   Nodes counted = 4 [OK]

Hint: Add 1 for root plus counts of left and right [OK]

Common Mistakes:

• Counting only children, missing root
• Miscounting null nodes
• Adding extra nodes

4. Identify the error in this C# method to count total nodes in a binary tree:

int CountNodes(Node root) {
  if (root == null) return 1;
  return CountNodes(root.left) + CountNodes(root.right);
}

medium

A. Returns 1 for null node instead of 0

B. Does not count the current root node

C. All of the above

D. Missing addition of 1 for current node

Solution

1. Step 1: Check base case return value

   Returning 1 for null node is incorrect; it should be 0 because null means no node.

2. Step 2: Check counting logic for current node

   Function does not add 1 for the current root node, so it misses counting it.

3. Step 3: Combine errors

   Both base case and missing addition cause wrong total count.

4. Final Answer:

   All of the above -> Option C

5. Quick Check:

   Base case and counting errors combined [OK]

Hint: Base case returns 0; add 1 for current node [OK]

Common Mistakes:

• Returning 1 for null node
• Not adding 1 for current node
• Ignoring base case correctness

5. Given a binary tree where some nodes have only one child, how would you modify the counting function to count only nodes that have at least one child?

hard

A. Count only leaf nodes

B. Count nodes where left or right child is not null, recursively

C. Count all nodes including leaves

D. Count nodes with both children null

Solution

1. Step 1: Define condition for counting nodes

   We want to count nodes that have at least one child, so check if left or right child is not null.

2. Step 2: Modify recursive function accordingly

   Recursively count nodes where left or right child exists, ignoring leaf nodes with no children.

3. Step 3: Implement logic

   Return 1 + counts of children if node has child; else 0 for leaf nodes.

4. Final Answer:

   Count nodes where left or right child is not null, recursively -> Option B

5. Quick Check:

   Count nodes with children only [OK]

Hint: Count nodes with at least one child only [OK]

Common Mistakes:

• Counting all nodes including leaves
• Counting only leaves
• Counting nodes with no children