Right Side View of Binary Tree in DSA C#

Mental Model

We want to see the nodes visible when looking at the tree from the right side, which means the rightmost node at each level.

Analogy: Imagine standing on the right side of a tall building with many floors and windows. You only see the windows on the right edge of each floor, not the ones behind.

       1
      / \
     2   3
      \   \
       5   4

Right side view: 1 -> 3 -> 4

Dry Run Walkthrough

Input: Binary tree: 1 -> 2, 3; 2 -> null, 5; 3 -> null, 4

Goal: Find the rightmost node at each level to form the right side view list

Step 1: Start level order traversal from root node 1

Level 0: [1]
Rightmost node: 1

Why: We begin from the top level, the root is always visible

Step 2: Move to level 1, nodes are 2 and 3

Level 1: [2, 3]
Rightmost node: 3

Why: At level 1, the rightmost node is 3, so it is visible from right side

Step 3: Move to level 2, nodes are 5 and 4 (children of 2 and 3)

Level 2: [5, 4]
Rightmost node: 4

Why: At level 2, the rightmost node is 4, so it is visible from right side

Result:

Right side view list: [1, 3, 4]

Annotated Code

DSA C#

using System;
using System.Collections.Generic;

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 levelSize = queue.Count;
            for (int i = 0; i < levelSize; i++) {
                TreeNode node = queue.Dequeue();
                if (node.left != null) queue.Enqueue(node.left);
                if (node.right != null) queue.Enqueue(node.right);
                if (i == levelSize - 1) result.Add(node.val);
            }
        }
        return result;
    }

    public static void Main() {
        TreeNode root = new TreeNode(1,
            new TreeNode(2, null, new TreeNode(5)),
            new TreeNode(3, null, new TreeNode(4))
        );
        Solution sol = new Solution();
        var rightView = sol.RightSideView(root);
        Console.WriteLine(string.Join(", ", rightView));
    }
}

queue.Enqueue(root);

Start BFS traversal from root node

int levelSize = queue.Count;

Determine number of nodes at current level

TreeNode node = queue.Dequeue();

Process nodes level by level

if (node.left != null) queue.Enqueue(node.left);

Add left child to queue for next level

if (node.right != null) queue.Enqueue(node.right);

Add right child to queue for next level

if (i == levelSize - 1) result.Add(node.val);

Add rightmost node of current level to result

Output

1, 3, 4

Complexity Analysis

Time: O(n) because we visit each node exactly once during the breadth-first traversal

Space: O(n) because in the worst case the queue can hold all nodes at the last level

vs Alternative: Compared to a depth-first approach, BFS naturally processes nodes level by level making it easier to identify rightmost nodes without extra bookkeeping

Edge Cases

Empty tree (root is null)

Returns an empty list since there are no nodes to view

DSA C#

if (root == null) return result;

Tree with only one node

Returns a list with that single node value

DSA C#

queue.Enqueue(root);

Tree where all nodes only have left children

Right side view is all nodes since each level has only one node

DSA C#

if (node.left != null) queue.Enqueue(node.left);

When to Use This Pattern

When asked to find visible nodes from one side of a tree, use level order traversal and pick the last node at each level to get the side view.

Common Mistakes

Mistake: Adding the first node of each level instead of the last node
Fix: Add the node value only when processing the last node in the current level loop

Mistake: Using preorder traversal which does not process nodes level by level
Fix: Use breadth-first search (queue) to process nodes level by level

Summary

Finds the rightmost node at each level of a binary tree to show the right side view.

Use when you need to see which nodes are visible when looking at the tree from the right side.

The key is to do a level order traversal and record the last node at each level.

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