Count Total Nodes in Binary Tree in DSA Go - Execution Trace

Concept Flow - Count Total Nodes in Binary Tree

Start at root node

↓

Is node null?

Yes→Return 0

No↓

Count left subtree nodes

↓

Count right subtree nodes

↓

Add 1 (current node) + left + right

↓

Return total count

The process starts at the root, checks if the node is null, then recursively counts nodes in left and right subtrees, adds 1 for the current node, and returns the total.

Execution Sample

DSA Go

func countNodes(root *Node) int {
    if root == nil {
        return 0
    }
    return 1 + countNodes(root.Left) + countNodes(root.Right)
}

This function counts all nodes in a binary tree by recursively summing nodes in left and right subtrees plus the current node.

Execution Table

Step	Operation	Node Visited	Left Count	Right Count	Total Count	Tree State
1	Visit root	1	-	-	-	1 / \ 2 3
2	Visit left child	2	-	-	-	1 / \ 2 3
3	Visit left.left (nil)	nil	0	0	0	1 / \ 2 3
4	Visit left.right (nil)	nil	0	0	0	1 / \ 2 3
5	Count left subtree of node 2	2	0	0	1	1 / \ 2 3
6	Visit right child	3	-	-	-	1 / \ 2 3
7	Visit right.left (nil)	nil	0	0	0	1 / \ 2 3
8	Visit right.right (nil)	nil	0	0	0	1 / \ 2 3
9	Count right subtree of node 3	3	0	0	1	1 / \ 2 3
10	Count total nodes at root	1	1	1	3	1 / \ 2 3
11	Return total count	root	-	-	3	1 / \ 2 3

💡 All nodes visited; recursion ends when nil nodes are reached returning 0.

Variable Tracker

Variable	Start	After Step 2	After Step 5	After Step 9	Final
Current Node	1 (root)	2 (left child)	2 (left child)	3 (right child)	1 (root)
Left Count	-	-	0	0	1
Right Count	-	-	-	0	1
Total Count	-	-	1	1	3

Key Moments - 3 Insights

Why do we return 0 when the node is nil?

Because a nil node means no node exists there, so it contributes zero to the count. This is shown in steps 3, 4, 7, and 8 where nil nodes return 0.

How does the function add counts from left and right subtrees?

The function recursively calls itself on left and right children, sums their counts, and adds 1 for the current node. This is clear in steps 5, 9, and 10.

Why do we add 1 in the return statement?

The 1 accounts for the current node itself. Without it, only children would be counted. Step 10 shows adding 1 + left + right counts.

Visual Quiz - 3 Questions

Look at the execution table, what is the total count returned at step 10?

A 1

B 2

C 3

D 0

💡 Hint

Check the 'Total Count' column at step 10 in the execution_table.

At which step does the function visit the right child of the root?

A Step 2

B Step 6

C Step 9

D Step 5

💡 Hint

Look at the 'Operation' and 'Node Visited' columns to find when node 3 is visited.

If the left child of the root had one child node, how would the total count at step 10 change?

A It would increase by 1

B It would decrease by 1

C It would stay the same

D It would double

💡 Hint

Adding a node increases total count by 1; check how counts are summed in steps 5 and 10.

Concept Snapshot

CountTotalNodes(root):
- If root is nil, return 0
- Else return 1 + CountTotalNodes(root.Left) + CountTotalNodes(root.Right)
- Recursively counts all nodes in left and right subtrees
- Adds 1 for current node
- Returns total nodes in tree

Full Transcript

This visualization shows how to count total nodes in a binary tree using recursion. Starting at the root, the function checks if the node is nil. If yes, it returns 0. Otherwise, it recursively counts nodes in the left subtree, then the right subtree, adds 1 for the current node, and returns the sum. The execution table traces each step visiting nodes 1, 2, and 3, including nil children returning 0. The variable tracker shows how counts accumulate. Key moments clarify why nil nodes return 0, why 1 is added for the current node, and how left and right counts combine. The quiz tests understanding of counts at specific steps and effects of adding nodes.

Practice

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

easy

A. It counts only the leaf nodes of the tree.

B. It counts all nodes including root, left, and right children.

C. It counts only the nodes on the left side of the tree.

D. It counts only the nodes on the right side of the tree.

Solution

1. Step 1: Understand node counting in binary tree

   Counting total nodes means including every node: root, left child, and right child recursively.

2. Step 2: Compare options with definition

   Only the option that says 'It counts all nodes including root, left, and right children.' includes all nodes, others limit to parts of the tree.

3. Final Answer:

   It counts all nodes including root, left, and right children. -> Option B

4. Quick Check:

   Total nodes = all nodes in tree [OK]

Hint: Count every node, not just leaves or sides [OK]

Common Mistakes:

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

2. Which of the following Go function signatures correctly defines a function to count nodes in a binary tree with root type *Node?

easy

A. func countNodes(root *Node) string

B. func countNodes(root Node) int

C. func countNodes(root *Node) int

D. func countNodes(root Node) bool

Solution

1. Step 1: Identify correct parameter type

   Binary tree root is usually a pointer to Node, so *Node is correct.

2. Step 2: Identify correct return type

   Counting nodes returns an integer, so return type int is correct.

3. Final Answer:

   func countNodes(root *Node) int -> Option C

4. Quick Check:

   Pointer parameter and int return type [OK]

Hint: Use pointer receiver and int return for count function [OK]

Common Mistakes:

• Passing Node by value instead of pointer
• Returning wrong type like string or bool
• Missing pointer in parameter

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

package main

import "fmt"

type Node struct {
  Val   int
  Left  *Node
  Right *Node
}

func countNodes(root *Node) int {
  if root == nil {
    return 0
  }
  return 1 + countNodes(root.Left) + countNodes(root.Right)
}

func main() {
  root := &Node{Val: 1}
  root.Left = &Node{Val: 2}
  root.Right = &Node{Val: 3}
  root.Left.Left = &Node{Val: 4}
  fmt.Println(countNodes(root))
}

medium

A. 6

B. 3

C. 5

D. 4

Solution

1. Step 1: Count nodes in the tree structure

   Nodes are: 1 (root), 2 (left), 3 (right), 4 (left-left). Total = 4 nodes.

2. Step 2: Verify counting logic in code

   Code counts root + left subtree + right subtree recursively, so total nodes = 4.

3. Final Answer:

   4 -> Option D

4. Quick Check:

   Count nodes recursively = 4 [OK]

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

Common Mistakes:

• Counting only root and immediate children
• Forgetting to count left-left node
• Misreading tree structure

4. Identify the error in this Go function to count total nodes in a binary tree:

func countNodes(root *Node) int {
  if root == nil {
    return 1
  }
  return 1 + countNodes(root.Left) + countNodes(root.Right)
}

medium

A. Returns 1 when root is nil, should return 0.

B. Missing base case for leaf nodes.

C. Returns sum without counting current node.

D. Function signature is incorrect.

Solution

1. Step 1: Check base case for nil node

   When root is nil, it means no node, so should return 0, not 1.

2. Step 2: Verify the counting logic

   The return statement correctly adds 1 for the current node plus recurses on left and right subtrees.

3. Final Answer:

   Returns 1 when root is nil, should return 0. -> Option A

4. Quick Check:

   Nil node count = 0, not 1 [OK]

Hint: Base case for nil node must return 0 [OK]

Common Mistakes:

• Returning 1 for nil node
• Not adding 1 for current node
• Incorrect base case logic

5. Given a binary tree where each node has a value, how would you modify the countNodes function to count only nodes with even values?

hard

A. Add a check: if node value is even, add 1; else add 0, then recurse.

B. Count all nodes and subtract nodes with odd values after traversal.

C. Only traverse left subtree if node value is even.

D. Return 1 for every node regardless of value.

Solution

1. Step 1: Add condition to count only even nodes

   Check if current node's value is even; if yes, count 1, else 0.

2. Step 2: Recursively count even nodes in left and right subtrees

   Sum counts from left and right subtrees with current node's count.

3. Final Answer:

   Add a check: if node value is even, add 1; else add 0, then recurse. -> Option A

4. Quick Check:

   Count only even nodes by conditional addition [OK]

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

Common Mistakes:

• Counting all nodes then subtracting odd nodes
• Skipping subtrees based on node value
• Ignoring node values in count