Right Side View of Binary Tree in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to add the root node's value to the result list.

DSA C#

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

Drag options to blanks, or click blank then click option'

A0

BlevelSize - 1

ClevelSize

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Adding the first node (index 0) instead of the last node.

Using levelSize instead of levelSize - 1 causing index errors.

We add the node's value when i equals levelSize - 1 because that is the last node in the current level, representing the rightmost node visible from the right side.

2fill in blank

medium

Complete the code to enqueue the left child node if it exists.

DSA C#

if (node.left != null) [1];

Drag options to blanks, or click blank then click option'

Aqueue.Enqueue(root)

Bqueue.Enqueue(node.right)

Cqueue.Enqueue(node.left)

Dqueue.Enqueue(node)

Attempts:

3 left

💡 Hint

Common Mistakes

Enqueuing the right child instead of the left child.

Enqueuing the current node again causing infinite loops.

We enqueue node.left to process the left child nodes in the next level.

3fill in blank

hard

Fix the error in the code to correctly initialize the queue with the root node.

DSA C#

var queue = new Queue<TreeNode>();
[1];

Drag options to blanks, or click blank then click option'

Aqueue.Enqueue(root.right);

Bqueue.Enqueue(null);

Cqueue.Enqueue(root.left);

Dqueue.Enqueue(root);

Attempts:

3 left

💡 Hint

Common Mistakes

Enqueuing null or child nodes before the root.

Not enqueuing any node causing the loop to never run.

We must enqueue the root node to start the level order traversal.

4fill in blank

hard

Fill both blanks to correctly check and enqueue the right child node.

DSA C#

if ([1] != null) [2];

Drag options to blanks, or click blank then click option'

Anode.right

Bqueue.Enqueue(node.left)

Cqueue.Enqueue(node.right)

Dnode.left

Attempts:

3 left

💡 Hint

Common Mistakes

Checking the left child but enqueuing the right child or vice versa.

Enqueuing the left child twice.

We check if node.right exists and enqueue it to process right child nodes.

5fill in blank

hard

Fill all three blanks to complete the method signature and return type for right side view.

DSA C#

public [1] [2](TreeNode [3]) {
    // method body
}

Drag options to blanks, or click blank then click option'

AList<int>

BRightSideView

Croot

Dvoid

Attempts:

3 left

💡 Hint

Common Mistakes

Using void as return type instead of List.

Wrong method name or parameter name.

The method returns a list of integers, is named RightSideView, and takes root as parameter.

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