Top View of Binary Tree in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Top View for a Simple Binary Tree

What is the printed top view of the binary tree after running the given code?

DSA C#

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

class BinaryTree {
    public Node root;

    public void TopView() {
        if (root == null) return;
        var map = new SortedDictionary<int, int>();
        var queue = new Queue<(Node node, int hd)>();
        queue.Enqueue((root, 0));

        while (queue.Count > 0) {
            var (node, hd) = queue.Dequeue();
            if (!map.ContainsKey(hd)) {
                map[hd] = node.data;
            }
            if (node.left != null) queue.Enqueue((node.left, hd - 1));
            if (node.right != null) queue.Enqueue((node.right, hd + 1));
        }

        foreach (var val in map.Values) {
            Console.Write(val + " ");
        }
    }
}

var tree = new BinaryTree();
tree.root = new Node(1);
tree.root.left = new Node(2);
tree.root.right = new Node(3);
tree.root.left.right = new Node(4);
tree.root.left.right.right = new Node(5);
tree.root.left.right.right.right = new Node(6);
tree.TopView();

A 1 2 3 4 5 6

B 2 4 1 3 6

C 1 2 3 5 6

D 2 1 3 6

💡 Hint

Think about horizontal distances and which nodes appear first at each horizontal distance.

The top view prints nodes visible from the top. It uses horizontal distance (hd) from root. The first node at each hd is printed.

Here, nodes at hd -1: 2, hd 0: 1, hd 1: 3, hd 2: 6 appear first.

🧠 Conceptual

intermediate

Understanding Horizontal Distance in Top View

In the top view of a binary tree, what does the horizontal distance (hd) represent?

A The distance of the node from the root along the horizontal axis, where left child decreases hd by 1 and right child increases hd by 1

B The number of nodes in the subtree rooted at that node

C The depth of the node from the root

D The vertical level of the node in the tree

💡 Hint

Think about how left and right children affect horizontal position relative to root.

Horizontal distance is used to track the horizontal position of nodes relative to the root. Left child decreases hd by 1, right child increases hd by 1.

🔧 Debug

advanced

Identify the Bug in Top View Implementation

What error will occur when running the following code snippet for top view of a binary tree?

DSA C#

var map = new Dictionary<int, int>();
var queue = new Queue<(Node node, int hd)>();
queue.Enqueue((root, 0));

while (queue.Count > 0) {
    var (node, hd) = queue.Dequeue();
    map[hd] = node.data;
    if (node.left != null) queue.Enqueue((node.left, hd - 1));
    if (node.right != null) queue.Enqueue((node.right, hd + 1));
}

foreach (var val in map.Values) {
    Console.Write(val + " ");
}

A Prints bottom view instead of top view

B No error; prints the correct top view

C Throws KeyNotFoundException

D Compilation error due to tuple deconstruction

💡 Hint

Check how the map is updated for each horizontal distance.

The code overwrites the value for each horizontal distance, so the last node at each hd is stored, which corresponds to the bottom view, not top view.

🚀 Application

advanced

Top View of a Complex Binary Tree

Given the binary tree constructed by the code below, what is the top view output?

DSA C#

var tree = new BinaryTree();
tree.root = new Node(10);
tree.root.left = new Node(20);
tree.root.right = new Node(30);
tree.root.left.left = new Node(40);
tree.root.left.right = new Node(50);
tree.root.right.left = new Node(60);
tree.root.right.right = new Node(70);
tree.root.left.right.left = new Node(80);
tree.root.left.right.right = new Node(90);
tree.TopView();

A 40 20 50 10 30 70

B 40 20 10 30 70

C 40 20 10 60 30 70

D 20 10 30 60 70

💡 Hint

Remember to print only the first node encountered at each horizontal distance from left to right.

The top view includes nodes at horizontal distances -2:40, -1:20, 0:10, 1:30, 2:70.

Nodes 50, 60, 80, 90 are hidden behind others when viewed from top.

🧠 Conceptual

expert

Why Use a Sorted Dictionary in Top View Implementation?

Why is a sorted dictionary (or sorted map) preferred when storing nodes by horizontal distance in top view of a binary tree?

A To ensure nodes are stored in insertion order

B To maintain nodes in order of their vertical depth

C To output the top view nodes from leftmost to rightmost horizontal distance

D To allow duplicate keys for nodes at same horizontal distance

💡 Hint

Think about how the final output should be ordered horizontally.

The sorted dictionary keeps keys (horizontal distances) in ascending order, so when printing, nodes appear from left to right.

Practice

1. What does the Top View of a binary tree represent?

easy

A. Nodes visible when the tree is viewed from the top

B. Nodes visible when the tree is viewed from the left side

C. Nodes visible when the tree is viewed from the right side

D. All leaf nodes of the tree

Solution

1. Step 1: Understand the top view concept

   The top view of a binary tree includes all nodes visible when looking down from above the tree.

2. Step 2: Differentiate from other views

   Left or right views show nodes from side angles, while top view shows nodes from above.

3. Final Answer:

   Nodes visible when the tree is viewed from the top -> Option A

4. Quick Check:

   Top view = nodes seen from above [OK]

Hint: Top view shows nodes visible from above the tree [OK]

Common Mistakes:

• Confusing top view with left or right side views
• Thinking top view includes all leaf nodes
• Assuming top view shows all nodes in the tree

2. Which of the following C# code snippets correctly declares a node class for a binary tree used in top view calculation?

easy

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

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

C. public struct Node { public int data; public Node left, right; public Node(int val) { data = val; left = right = null; } }

D. public class Node { int data; Node left, right; Node() { data = 0; left = right = null; } }

Solution

1. Step 1: Check access modifiers and constructor

   public class Node { public int data; public Node left, right; public Node(int val) { data = val; left = right = null; } } uses public class, public fields, and a constructor with parameter, which is correct for node definition.

2. Step 2: Identify issues in other options

   class Node { int data; Node left, right; Node(int val) { data = val; left = right = null; } } lacks access modifiers (default private), public struct Node { public int data; public Node left, right; public Node(int val) { data = val; left = right = null; } } uses struct which is not typical for tree nodes, public class Node { int data; Node left, right; Node() { data = 0; left = right = null; } } lacks constructor parameter and fields are private.

3. Final Answer:

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

4. Quick Check:

   Public class with constructor and public fields = public class Node { public int data; public Node left, right; public Node(int val) { data = val; left = right = null; } } [OK]

Hint: Use public class with constructor and public fields for nodes [OK]

Common Mistakes:

• Omitting public access modifiers causing inaccessible fields
• Using struct instead of class for nodes
• Not initializing left and right to null

3. Consider the following binary tree:

        1
       / \
      2   3
       \   \
        4   5
         \
          6

What is the top view of this tree?

medium

A. [2, 1, 3, 6]

B. [1, 2, 4, 6, 5]

C. [2, 1, 3, 5]

D. [1, 2, 3, 4, 5, 6]

Solution

1. Step 1: Assign horizontal distances (HD) to nodes

   Root (1) has HD=0, left child (2) HD=-1, right child (3) HD=1, node 4 (right of 2) HD=0, node 5 (right of 3) HD=2, node 6 (right of 4) HD=1.

2. Step 2: Select topmost nodes at each HD

   Using BFS order, first node at each HD: HD -1: 2, HD 0: 1 (4 hidden below), HD 1: 3 (6 hidden below), HD 2: 5. Sorted by HD: [2, 1, 3, 5]

3. Final Answer:

   [2, 1, 3, 5] -> Option C

4. Quick Check:

   Top view nodes by HD = [2, 1, 3, 5] [OK]

Hint: Track horizontal distances and pick first node at each HD [OK]

Common Mistakes:

• Ignoring horizontal distances and picking all nodes
• Confusing top view with level order traversal
• Missing nodes with same horizontal distance but different levels

4. The following C# code attempts to print the top view of a binary tree but has a bug. What is the error?

void PrintTopView(Node root) {
  if (root == null) return;
  var map = new Dictionary<int, int>();
  var queue = new Queue<(Node node, int hd)>();
  queue.Enqueue((root, 0));
  while (queue.Count > 0) {
    var (node, hd) = queue.Dequeue();
    map[hd] = node.data;
    if (node.left != null) queue.Enqueue((node.left, hd - 1));
    if (node.right != null) queue.Enqueue((node.right, hd + 1));
  }
  foreach (var key in map.Keys.OrderBy(k => k)) {
    Console.Write(map[key] + " ");
  }
}

medium

A. It does not check for null root

B. It does not enqueue the root node

C. It uses a queue instead of a stack

D. It overwrites nodes at the same horizontal distance instead of keeping the first

Solution

1. Step 1: Analyze map update logic

   The code assigns map[hd] = node.data every time, overwriting previous entries at the same horizontal distance.

2. Step 2: Understand top view requirement

   Top view requires the first node encountered at each horizontal distance, so overwriting causes incorrect output.

3. Final Answer:

   It overwrites nodes at the same horizontal distance instead of keeping the first -> Option D

4. Quick Check:

   Keep first node per HD, not overwrite [OK]

Hint: Store node only if HD not already in map [OK]

Common Mistakes:

• Overwriting map entries for horizontal distances
• Ignoring null root check (though present here)
• Confusing queue with stack usage

5. You want to find the top view of a binary tree but only have access to its inorder and level order traversals:

Inorder: [4, 2, 5, 1, 6, 3, 7]
Level order: [1, 2, 3, 4, 5, 6, 7]

Which approach is best to find the top view?

hard

A. Use level order traversal directly to get top view

B. Reconstruct the tree from traversals, then perform top view traversal

C. Use inorder traversal directly to get top view

D. Top view cannot be found from these traversals

Solution

1. Step 1: Understand traversal information

   Inorder and level order traversals can be used together to reconstruct the binary tree uniquely.

2. Step 2: Apply top view after reconstruction

   Once the tree is rebuilt, perform a top view traversal using horizontal distances and BFS.

3. Final Answer:

   Reconstruct the tree from traversals, then perform top view traversal -> Option B

4. Quick Check:

   Rebuild tree first, then find top view [OK]

Hint: Rebuild tree from traversals before top view [OK]

Common Mistakes:

• Trying to get top view directly from inorder or level order
• Assuming top view is same as level order
• Believing top view cannot be found from given traversals