Tree Terminology Root Leaf Height Depth Level in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Tree Node Levels

What is the output of the following C# code that prints the level of each node in a simple tree?

DSA C#

using System;
using System.Collections.Generic;

class TreeNode {
    public int Value;
    public List<TreeNode> Children = new List<TreeNode>();
    public TreeNode(int val) { Value = val; }
}

class Program {
    static void PrintLevels(TreeNode node, int level) {
        Console.WriteLine($"Node {node.Value} is at level {level}");
        foreach (var child in node.Children) {
            PrintLevels(child, level + 1);
        }
    }

    static void Main() {
        TreeNode root = new TreeNode(1);
        TreeNode child1 = new TreeNode(2);
        TreeNode child2 = new TreeNode(3);
        TreeNode grandchild = new TreeNode(4);
        root.Children.Add(child1);
        root.Children.Add(child2);
        child1.Children.Add(grandchild);
        PrintLevels(root, 0);
    }
}

A

Node 1 is at level 1
Node 2 is at level 2
Node 4 is at level 3
Node 3 is at level 2

B

Node 1 is at level 0
Node 2 is at level 1
Node 4 is at level 2
Node 3 is at level 1

C

Node 1 is at level 0
Node 2 is at level 0
Node 4 is at level 1
Node 3 is at level 0

D

Node 1 is at level 1
Node 2 is at level 1
Node 4 is at level 2
Node 3 is at level 1

💡 Hint

Remember that the root node starts at level 0 and each child node increases the level by 1.

The root node is at level 0. Its children are at level 1, and their children are at level 2. The code recursively prints each node's level correctly.

🧠 Conceptual

intermediate

Identify Leaf Nodes in a Tree

In a tree, which nodes are called leaf nodes?

A Nodes with no children

B Nodes with exactly one child

C The root node only

D Nodes with two or more children

💡 Hint

Leaf nodes do not have any nodes connected below them.

Leaf nodes are nodes that have no children. They are the end points of the tree branches.

❓ Predict Output

advanced

Calculate Height of a Tree

What is the output of this C# code that calculates the height of a tree?

DSA C#

using System;
using System.Collections.Generic;

class TreeNode {
    public int Value;
    public List<TreeNode> Children = new List<TreeNode>();
    public TreeNode(int val) { Value = val; }
}

class Program {
    static int Height(TreeNode node) {
        if (node.Children.Count == 0) return 0;
        int maxChildHeight = 0;
        foreach (var child in node.Children) {
            int childHeight = Height(child);
            if (childHeight > maxChildHeight) maxChildHeight = childHeight;
        }
        return maxChildHeight + 1;
    }

    static void Main() {
        TreeNode root = new TreeNode(1);
        TreeNode child1 = new TreeNode(2);
        TreeNode child2 = new TreeNode(3);
        TreeNode grandchild1 = new TreeNode(4);
        TreeNode grandchild2 = new TreeNode(5);
        root.Children.Add(child1);
        root.Children.Add(child2);
        child1.Children.Add(grandchild1);
        child1.Children.Add(grandchild2);
        Console.WriteLine(Height(root));
    }
}

A 2

B 3

C 1

D 0

💡 Hint

Height is the longest path from root to a leaf node in terms of edges.

The longest path from root to leaf is 2 edges: root->child1->grandchild1 or grandchild2. So height is 2.

🧠 Conceptual

advanced

Depth of a Node in a Tree

What does the depth of a node in a tree represent?

A Number of nodes in the tree

B Number of children the node has

C Number of leaf nodes in the subtree rooted at that node

D Number of edges from the root to that node

💡 Hint

Depth measures how far a node is from the root.

Depth is the count of edges from the root node down to the node in question.

🚀 Application

expert

Determine Level of Nodes After Insertions

Given the following insertions in a tree, what is the level of node with value 7?

DSA C#

using System;
using System.Collections.Generic;

class TreeNode {
    public int Value;
    public List<TreeNode> Children = new List<TreeNode>();
    public TreeNode(int val) { Value = val; }
}

class Program {
    static int FindLevel(TreeNode node, int val, int level) {
        if (node.Value == val) return level;
        foreach (var child in node.Children) {
            int found = FindLevel(child, val, level + 1);
            if (found != -1) return found;
        }
        return -1;
    }

    static void Main() {
        TreeNode root = new TreeNode(1);
        TreeNode n2 = new TreeNode(2);
        TreeNode n3 = new TreeNode(3);
        TreeNode n4 = new TreeNode(4);
        TreeNode n5 = new TreeNode(5);
        TreeNode n6 = new TreeNode(6);
        TreeNode n7 = new TreeNode(7);

        root.Children.Add(n2);
        root.Children.Add(n3);
        n2.Children.Add(n4);
        n2.Children.Add(n5);
        n3.Children.Add(n6);
        n6.Children.Add(n7);

        Console.WriteLine(FindLevel(root, 7, 0));
    }
}

A 4

B 2

C 3

D 1

💡 Hint

Count edges from root to node 7.

Path: root(1) level 0 -> n3 level 1 -> n6 level 2 -> n7 level 3. So level is 3.

Practice

1. In a tree data structure, which node is called the root?

easy

A. The topmost node with no parent

B. A node with no children

C. Any node at the bottom level

D. A node with exactly two children

Solution

1. Step 1: Understand the root node concept

   The root node is the starting point of a tree and has no parent node above it.

2. Step 2: Identify the correct description

   Among the options, only the topmost node with no parent matches the root node definition.

3. Final Answer:

   The topmost node with no parent -> Option A

4. Quick Check:

   Root = topmost node with no parent [OK]

Hint: Root is the very first node without a parent [OK]

Common Mistakes:

• Confusing root with leaf nodes
• Thinking root must have children
• Assuming root is any node at the bottom

2. Which of the following is the correct way to declare a simple tree node class in C# with a value and children list?

easy

A. class Node { int Value; int Children; }

B. class Node { public int Value; public Node Children; }

C. class Node { public int Value; public List<Node> Children; }

D. class Node { public int Value; public Node[] Children; }

Solution

1. Step 1: Check for correct data types and access modifiers

   The node should have a public integer value and a list of child nodes. class Node { public int Value; public List<Node> Children; } uses List<Node> which is correct.

2. Step 2: Eliminate incorrect options

   class Node { int Value; int Children; } uses int for children which is wrong. class Node { public int Value; public Node Children; } uses a single Node for children instead of a list. class Node { public int Value; public Node[] Children; } uses an array which is valid but less flexible than List.

3. Final Answer:

   class Node { public int Value; public List<Node> Children; } -> Option C

4. Quick Check:

   Use List<Node> for children in C# [OK]

Hint: Use List<Node> for multiple children in C# [OK]

Common Mistakes:

• Using int instead of List<Node> for children
• Missing public access modifier
• Using single Node instead of collection for children

3. Given a tree where the root is at level 0, what is the level of a leaf node that is 4 edges away from the root?

easy

A. 3

B. 4

C. 5

D. 6

Solution

1. Step 1: Understand level definition

   Level of a node is the number of edges from the root to that node, starting at 0 for root.

2. Step 2: Calculate leaf node level

   If leaf is 4 edges away from root, its level is 4.

3. Final Answer:

   4 -> Option B

4. Quick Check:

   Level = edges from root = 4 [OK]

Hint: Level equals number of edges from root [OK]

Common Mistakes:

• Confusing level with height
• Starting level count at 1 instead of 0
• Mixing depth and level definitions

4. Consider the following tree structure:

Node root = new Node { Value = 1, Children = new List<Node> {
  new Node { Value = 2, Children = new List<Node> {
    new Node { Value = 4, Children = new List<Node>() },
    new Node { Value = 5, Children = new List<Node>() }
  }},
  new Node { Value = 3, Children = new List<Node>() }
}};

What is the height of this tree?

medium

A. 2

B. 3

C. 1

D. 4

Solution

1. Step 1: Understand height definition

   Height is the number of edges on the longest path from the root to a leaf node.

2. Step 2: Trace the longest path in the tree

   Longest path: root(1) -> 2 -> 4 (or 5). This path has 2 edges, so height = 2.

3. Step 3: Reconsider height counting

   Height is often defined as the number of nodes on the longest path minus 1, which equals the number of edges. The path has 3 nodes (1,2,4), so height = 2 edges, which is correct. However, some definitions count height as number of nodes, which would be 3.

4. Step 4: Confirm standard definition

   Standard definition: height = number of edges = 2.

5. Final Answer:

   2 -> Option A

6. Quick Check:

   Height = longest path edges = 2 [OK]

Hint: Height = number of edges on longest root-to-leaf path [OK]

Common Mistakes:

• Counting nodes instead of edges for height
• Confusing height with depth
• Ignoring leaf nodes at bottom

5. The following code tries to calculate the depth of a node in a tree but has a bug:

int GetDepth(Node node) {
  if (node == null) return 0;
  return 1 + GetDepth(node.Children[0]);
}

What is the main problem with this code?

medium

A. It causes infinite recursion for leaf nodes

B. It returns 0 for null nodes instead of -1

C. It does not handle the root node correctly

D. It only checks the first child, ignoring others

Solution

1. Step 1: Analyze recursion logic

   The function calls itself only on the first child (Children[0]), ignoring other children.

2. Step 2: Identify the bug impact

   This means it does not calculate depth correctly if node has multiple children; it misses deeper paths.

3. Final Answer:

   It only checks the first child, ignoring others -> Option D

4. Quick Check:

   Check all children for correct depth [OK]

Hint: Check all children, not just first, when calculating depth [OK]

Common Mistakes:

• Assuming single child trees only
• Ignoring null checks for children list
• Confusing depth with height