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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Right Side View for a Simple Binary Tree

What is the output of the following C# code that prints the right side view of a binary tree?

DSA C#

public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

public class Solution {
    public IList<int> RightSideView(TreeNode root) {
        var result = new List<int>();
        if (root == null) return result;
        var queue = new Queue<TreeNode>();
        queue.Enqueue(root);
        while (queue.Count > 0) {
            int size = queue.Count;
            for (int i = 0; i < size; i++) {
                var node = queue.Dequeue();
                if (node.left != null) queue.Enqueue(node.left);
                if (node.right != null) queue.Enqueue(node.right);
                if (i == size - 1) result.Add(node.val);
            }
        }
        return result;
    }
}

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

var root = new TreeNode(1,
    new TreeNode(2, null, new TreeNode(5)),
    new TreeNode(3, null, new TreeNode(4))
);
var sol = new Solution();
var output = sol.RightSideView(root);
System.Console.WriteLine(string.Join(", ", output));

A 1, 3, 4

B 1, 2, 5

C 1, 3, 5

D 1, 2, 4

💡 Hint

Think about which nodes are visible when looking from the right side level by level.

The right side view shows the last node at each level when traversed from left to right.

Level 1: Node 1

Level 2: Node 3 (right child of root)

Level 3: Node 4 (right child of node 3)

❓ Predict Output

intermediate

Right Side View Output for Left-Skewed Tree

What will be the output of the right side view function for this left-skewed binary tree?

DSA C#

// Tree structure:
//     1
//    /
//   2
//  /
// 3
//
var root = new TreeNode(1, new TreeNode(2, new TreeNode(3), null), null);
var sol = new Solution();
var output = sol.RightSideView(root);
System.Console.WriteLine(string.Join(", ", output));

A 3

B 1

C 1, 2, 3

D 1, 3

💡 Hint

Even if the tree is skewed to the left, the right side view includes the last node at each level.

Each level has only one node, so the right side view includes all nodes: 1, 2, and 3.

🔧 Debug

advanced

Identify the Error in Right Side View Implementation

What error will this code produce when trying to get the right side view of a binary tree?

DSA C#

public IList<int> RightSideView(TreeNode root) {
    var result = new List<int>();
    var queue = new Queue<TreeNode>();
    queue.Enqueue(root);
    while (queue.Count > 0) {
        int size = queue.Count;
        for (int i = 0; i < size; i++) {
            var node = queue.Dequeue();
            if (node.left != null) queue.Enqueue(node.left);
            if (node.right != null) queue.Enqueue(node.right);
            if (i == size - 1) result.Add(node.val);
        }
    }
    return result;
}

A System.InvalidOperationException: Queue empty on Dequeue

B NullReferenceException when root is null

C IndexOutOfRangeException in for loop

D No error, returns correct output

💡 Hint

Check the for loop boundary condition and how many times Dequeue is called.

The for loop uses i <= size, which causes one extra iteration than the number of elements in the queue.

This leads to calling Dequeue on an empty queue, causing InvalidOperationException.

🧠 Conceptual

advanced

Understanding the Data Structure Used in Right Side View

Which data structure is primarily used to implement the right side view of a binary tree in a level order traversal?

A Linked List

B HashSet

C Stack

D Queue

💡 Hint

Think about how nodes are processed level by level.

A queue is used to process nodes in FIFO order, which is essential for level order traversal.

🚀 Application

expert

Right Side View Output for Complex Tree

Given the following binary tree, what is the right side view output?

DSA C#

// Tree structure:
//         10
//        /  \
//       5    15
//      /    /  \
//     3    12  20
//      \        /
//       4      18

var root = new TreeNode(10,
    new TreeNode(5, new TreeNode(3, null, new TreeNode(4)), null),
    new TreeNode(15, new TreeNode(12), new TreeNode(20, new TreeNode(18), null))
);
var sol = new Solution();
var output = sol.RightSideView(root);
System.Console.WriteLine(string.Join(", ", output));

A 10, 15, 12, 18

B 10, 15, 20, 18

C 10, 5, 3, 4

D 10, 15, 20, 4

💡 Hint

Look at the rightmost node at each level from top to bottom.

Level 1: 10

Level 2: 15 (right child of 10)

Level 3: 20 (right child of 15)

Level 4: 18 (left child of 20)

Practice

1. What does the "Right Side View of Binary Tree" represent?
RightSideView(root) returns which nodes?

easy

A. All nodes at the deepest level of the tree

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

C. All leaf nodes of the binary tree

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

Solution

1. Step 1: Understand the problem context

   The right side view means seeing the tree from the right side, so only nodes visible from that angle are included.

2. Step 2: Identify what nodes are visible

   These are the rightmost nodes at each level of the tree, as nodes behind them are hidden.

3. Final Answer:

   Nodes visible when the tree is viewed from the right side -> Option D

4. Quick Check:

   Right side view = rightmost nodes [OK]

Hint: Right side view shows rightmost nodes at each level [OK]

Common Mistakes:

• Confusing right side view with left side view
• Including all leaf nodes instead of rightmost nodes
• Thinking it returns all nodes at the deepest level

2. Which of the following C# method signatures correctly represents a function to get the right side view of a binary tree?
class Solution { public IList<int> RightSideView(TreeNode root) { ... } }

easy

A. public List<TreeNode> RightSideView(int root)

B. public IList<int> RightSideView(TreeNode root)

C. public int RightSideView(TreeNode root)

D. public void RightSideView(TreeNode root)

Solution

1. Step 1: Analyze the return type

   The method should return a list of integers representing node values visible from the right side, so IList<int> is appropriate.

2. Step 2: Check parameter and method signature

   The parameter should be the root node of type TreeNode, and the method should return the list, not void or a single int.

3. Final Answer:

   public IList<int> RightSideView(TreeNode root) -> Option B

4. Quick Check:

   Return list of int values from TreeNode root [OK]

Hint: Return list of int, input is TreeNode root [OK]

Common Mistakes:

• Returning void instead of a list
• Returning a single int instead of a list
• Wrong parameter type like int instead of TreeNode

3. What is the output of the following code?

class TreeNode {
  public int val;
  public TreeNode left, right;
  public TreeNode(int v) { val = v; }
}

var root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.right = new TreeNode(5);
root.right.right = new TreeNode(4);

var result = RightSideView(root);
Console.WriteLine(string.Join(", ", result));

IList<int> RightSideView(TreeNode root) {
  var view = new List<int>();
  var queue = new Queue<TreeNode>();
  if (root != null) queue.Enqueue(root);
  while (queue.Count > 0) {
    int size = queue.Count;
    for (int i = 0; i < size; i++) {
      var node = queue.Dequeue();
      if (node.left != null) queue.Enqueue(node.left);
      if (node.right != null) queue.Enqueue(node.right);
      if (i == size - 1) view.Add(node.val);
    }
  }
  return view;
}

medium

A. [1, 3, 4]

B. [1, 2, 5]

C. [1, 3, 5]

D. [1, 2, 4]

Solution

1. Step 1: Trace the tree levels and nodes

   Level 1: Node 1; Level 2: Nodes 2 and 3; Level 3: Nodes 5 and 4.

2. Step 2: Identify rightmost nodes at each level

   Level 1 rightmost: 1; Level 2 rightmost: 3; Level 3 rightmost: 4.

3. Final Answer:

   [1, 3, 4] -> Option A

4. Quick Check:

   Rightmost nodes per level = [1, 3, 4] [OK]

Hint: Pick last node at each level in BFS order [OK]

Common Mistakes:

• Choosing leftmost nodes instead of rightmost
• Mixing node values from different levels
• Forgetting to add last node of each level

4. Find the error in this code snippet for right side view:

IList<int> RightSideView(TreeNode root) {
  var view = new List<int>();
  var queue = new Queue<TreeNode>();
  if (root != null) queue.Enqueue(root);
  while (queue.Count > 0) {
    int size = queue.Count;
    for (int i = 0; i <= size; i++) {
      var node = queue.Dequeue();
      if (node.left != null) queue.Enqueue(node.left);
      if (node.right != null) queue.Enqueue(node.right);
      if (i == size - 1) view.Add(node.val);
    }
  }
  return view;
}

medium

A. The root node should not be enqueued initially

B. The queue should be a Stack instead

C. The for loop condition should be i < size, not i <= size

D. The view list should be cleared inside the while loop

Solution

1. Step 1: Check the for loop boundary

   The for loop runs from i = 0 to i <= size, which means it runs size+1 times, causing an error when dequeueing.

2. Step 2: Correct the loop condition

   It should run exactly size times, so condition must be i < size to avoid dequeueing from empty queue.

3. Final Answer:

   The for loop condition should be i < size, not i <= size -> Option C

4. Quick Check:

   Loop runs size times, not size+1 [OK]

Hint: For loops over queue size use i < size, not i <= size [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Using stack instead of queue for BFS
• Clearing result list inside loop mistakenly

5. Given a binary tree where some nodes have only left children and others only right children, how would the right side view behave?
Example tree:

    1
   / 
  2   
   \   
    3
     \
      4

What is the right side view output?

hard

A. [1, 3, 4]

B. [4]

C. [1, 4]

D. [1, 2, 3, 4]

Solution

1. Step 1: Visualize the tree and levels

   Level 1: Node 1; Level 2: Node 2; Level 3: Node 3; Level 4: Node 4.

2. Step 2: Determine rightmost nodes at each level

   At level 2, node 2 is on the left, but node 3 is the right child of 2 and is visible from the right side. So the rightmost nodes per level are 1, 3, and 4.

3. Final Answer:

   [1, 3, 4] -> Option A

4. Quick Check:

   Right side view includes nodes visible from right side, skipping node 2 at level 2 [OK]

Hint: Right side view picks rightmost nodes at each level, even in skewed trees [OK]

Common Mistakes:

• Skipping nodes with only left children
• Assuming only right children appear in right side view
• Returning all nodes instead of rightmost nodes