Right Side View of Binary Tree in DSA C# - Execution Trace

Concept Flow - Right Side View of Binary Tree

Start at root node

↓

Initialize queue with root

↓

While queue not empty

↓

Get number of nodes at current level

↓

For each node in level

↓

Dequeue node

→If last node in level?

↓

Enqueue left child if exists

↓

Enqueue right child if exists

↓

Repeat for next level

↓

Return collected right side view

We traverse the tree level by level, from left to right, and record the last node's value at each level to get the right side view.

Execution Sample

DSA C#

Queue<TreeNode> 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 == levelSize - 1) rightView.Add(node.val);
    if(node.left != null) queue.Enqueue(node.left);
    if(node.right != null) queue.Enqueue(node.right);
  }
}

This code performs a level order traversal and collects the last node value of each level as the right side view.

Execution Table

Step	Operation	Node Visited	Queue State	Right View Collected	Visual Tree State
1	Initialize queue with root	1	[1]	[]	Root:1 / \ 2 3 / \ \ 4 5 6
2	Process level 1 (size=1)	1	[]	[1]	Root:1 / \ 2 3 / \ \ 4 5 6
3	Enqueue left child 2	1	[2]	[1]	Root:1 / \ 2 3 / \ \ 4 5 6
4	Enqueue right child 3	1	[2,3]	[1]	Root:1 / \ 2 3 / \ \ 4 5 6
5	Process level 2 (size=2)	2	[3]	[1]	Root:1 / \ 2 3 / \ \ 4 5 6
6	Enqueue left child 4	2	[3,4]	[1]	Root:1 / \ 2 3 / \ \ 4 5 6
7	Enqueue right child 5	2	[3,4,5]	[1]	Root:1 / \ 2 3 / \ \ 4 5 6
8	Process level 2 (size=2)	3	[4,5]	[1,3]	Root:1 / \ 2 3 / \ \ 4 5 6
9	Enqueue right child 6	3	[4,5,6]	[1,3]	Root:1 / \ 2 3 / \ \ 4 5 6
10	Process level 3 (size=3)	4	[5,6]	[1,3]	Root:1 / \ 2 3 / \ \ 4 5 6
11	No children to enqueue	4	[5,6]	[1,3]	Root:1 / \ 2 3 / \ \ 4 5 6
12	Process level 3 (size=3)	5	[6]	[1,3]	Root:1 / \ 2 3 / \ \ 4 5 6
13	No children to enqueue	5	[6]	[1,3]	Root:1 / \ 2 3 / \ \ 4 5 6
14	Process level 3 (size=3)	6	[]	[1,3,6]	Root:1 / \ 2 3 / \ \ 4 5 6
15	No children to enqueue	6	[]	[1,3,6]	Root:1 / \ 2 3 / \ \ 4 5 6
16	Queue empty, end traversal	-	[]	[1,3,6]	Traversal complete

💡 Queue is empty, all levels processed, right side view collected

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 8	After Step 14	Final
queue	[]	[]	[2,3]	[4,5]	[]	[]
rightView	[]	[1]	[1]	[1,3]	[1,3,6]	[1,3,6]
currentNode	null	1	1	3	6	6

Key Moments - 3 Insights

Why do we add the node value only when i == levelSize - 1?

Because i == levelSize - 1 means we are at the last node of the current level, which is the rightmost node visible from the right side. See execution_table rows 2, 8, and 14 where rightView is updated.

Why do we enqueue left child before right child if we want the right side view?

We enqueue left child first to maintain normal level order traversal. The rightmost node at each level is the last node processed, so it naturally appears last in the queue for that level. This is shown in execution_table rows 3-4 and 6-7.

What happens if the tree is empty (root is null)?

The queue starts empty, so the while loop never runs and the rightView remains empty. This is the base case not shown in the table but important to handle.

Visual Quiz - 3 Questions

Look at the execution_table at step 8, what is the rightView collected so far?

A [1]

B [1,3]

C [1,3,6]

D []

💡 Hint

Check the 'Right View Collected' column at step 8 in execution_table

At which step does the queue become empty, ending the traversal?

A Step 14

B Step 15

C Step 16

D Step 10

💡 Hint

Look at the 'Queue State' column and find when it becomes [] and traversal ends

If we enqueue right child before left child, how would the rightView change?

A It would remain the same

B It would collect leftmost nodes instead

C It would collect nodes in reverse order

D It would collect the first node of each level

💡 Hint

Enqueuing right child before left reverses the processing order to right-to-left per level, so the last processed node becomes the leftmost.

Concept Snapshot

Right Side View of Binary Tree:
- Use level order traversal (BFS) with a queue
- At each level, record the last node's value
- Enqueue left then right children
- Continue until queue is empty
- Result is list of rightmost nodes per level

Full Transcript

To find the right side view of a binary tree, we start from the root and use a queue to traverse the tree level by level. At each level, we process all nodes and record the value of the last node visited. We enqueue the left child first, then the right child, so the last node at each level is the rightmost visible node. We repeat this until the queue is empty. The collected values form the right side view of the tree.

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