Count Total Nodes in Binary Tree in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Counting Nodes in a Simple Binary Tree

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

DSA Go

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))
}

A 3

B 4

C 5

D 6

💡 Hint

Count each node including root, left subtree, and right subtree.

The tree has nodes with values 1, 2, 3, and 4. Total nodes = 4.

❓ Predict Output

intermediate

Count Nodes in a Skewed Binary Tree

What is the output of this Go code counting nodes in a skewed binary tree?

DSA Go

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: 10}
    root.Right = &Node{Val: 20}
    root.Right.Right = &Node{Val: 30}
    root.Right.Right.Right = &Node{Val: 40}
    fmt.Println(countNodes(root))
}

A 3

B 5

C 6

D 4

💡 Hint

Count all nodes along the right side.

The tree has nodes 10, 20, 30, and 40 linked rightwards. Total nodes = 4.

🔧 Debug

advanced

Identify the Error in Node Counting Function

What error will this Go code produce when counting nodes in a binary tree?

DSA Go

package main
import "fmt"
type Node struct {
    Val   int
    Left  *Node
    Right *Node
}
func countNodes(root *Node) int {
    if root == nil {
        return 1
    }
    return 1 + countNodes(root.Left) + countNodes(root.Right)
}
func main() {
    root := &Node{Val: 1}
    fmt.Println(countNodes(root))
}

A Returns 1 for empty tree, causing incorrect count

B Correctly returns 0 for empty tree

C Runtime panic due to nil pointer dereference

D Compilation error due to missing return statement

💡 Hint

Check the base case return value for nil node.

Returning 1 for nil node counts empty children as nodes, inflating count.

🧠 Conceptual

advanced

Time Complexity of Counting Nodes in Binary Tree

What is the time complexity of counting total nodes in a binary tree using recursion?

A O(n), where n is the number of nodes

B O(log n), where n is the number of nodes

C O(n^2), where n is the number of nodes

D O(1), constant time

💡 Hint

Each node is visited once in the recursion.

The function visits every node once, so time is proportional to number of nodes.

🚀 Application

expert

Count Nodes in a Binary Tree with Missing Children

Given the binary tree below, what is the total number of nodes? Structure: - Root node 5 - Left child 3 - Right child 8 - Left child of 3 is 1 - Right child of 3 is nil - Left child of 8 is nil - Right child of 8 is 10 Use the countNodes function below: func countNodes(root *Node) int { if root == nil { return 0 } return 1 + countNodes(root.Left) + countNodes(root.Right) }

A 4

B 6

C 5

D 3

💡 Hint

Count all nodes including those with nil children.

Nodes are 5, 3, 8, 1, and 10. Total is 5 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