Right Side View of Binary Tree in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the method that returns the right side view list.

DSA Java

public List<Integer> [1](TreeNode root) {
    List<Integer> result = new ArrayList<>();
    // method body
    return result;
}

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

AtopView

BrightSideView

CbottomView

DleftSideView

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'leftSideView' or other view names instead of 'rightSideView'.

The method name should be 'rightSideView' to match the problem requirement.

2fill in blank

medium

Complete the code to add the rightmost node's value at each level during BFS.

DSA Java

while (!queue.isEmpty()) {
    int size = queue.size();
    for (int i = 0; i < size; i++) {
        TreeNode node = queue.poll();
        if (i == [1]) {
            result.add(node.val);
        }
        if (node.left != null) queue.add(node.left);
        if (node.right != null) queue.add(node.right);
    }
}

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

Asize

B0

Csize - 1

Di + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 or size as the index to add node value instead of size - 1.

The rightmost node at each level is at index size - 1 in the loop.

3fill in blank

hard

Fix the error in the code that adds child nodes to the queue in BFS.

DSA Java

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

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

Apush

Bpeek

Cpop

Dadd

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'push' which is for stacks, or 'pop'/'peek' which remove or view elements.

In Java Queue, 'add' is used to insert elements at the end.

4fill in blank

hard

Fill both blanks to complete the DFS helper method that tracks depth and updates the right side view list.

DSA Java

private void dfs(TreeNode node, int [1], List<Integer> result) {
    if (node == null) return;
    if ([2] == result.size()) {
        result.add(node.val);
    }
    dfs(node.right, depth + 1, result);
    dfs(node.left, depth + 1, result);
}

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

Adepth

Blevel

Csize

Dindex

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names inconsistently for depth.

The variable tracking current depth is commonly named 'depth' and is compared to result.size().

5fill in blank

hard

Fill all three blanks to complete the DFS call in the main method and return the result.

DSA Java

List<Integer> result = new ArrayList<>();
dfs([1], [2], [3]);
return result;

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

Aroot

B0

Cresult

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Passing null or wrong initial depth.

The DFS call starts with root node, depth 0, and the result list.

Practice

1. What does the "Right Side View of Binary Tree" represent?

easy

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

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

C. All leaf nodes of the binary tree

D. All nodes at the deepest level of the tree

Solution

1. Step 1: Understand the view perspective

   The right side view shows nodes visible when looking at the tree from the right side.

2. Step 2: Differentiate from other views

   Unlike left side or leaf nodes, right side view includes the rightmost node at each level.

3. Final Answer:

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

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
• Thinking it shows all leaf nodes
• Assuming it shows all nodes at deepest level

2. Which of the following Java method signatures is correct for a function that returns the right side view of a binary tree as a list of integers?

easy

A. public int rightSideView(TreeNode root)

B. public void rightSideView(TreeNode root)

C. public List<Integer> rightSideView(TreeNode root)

D. public TreeNode rightSideView(List<Integer> root)

Solution

1. Step 1: Identify return type for right side view

   The right side view returns a list of integers representing node values visible from the right side.

2. Step 2: Match method signature

   Method should return List<Integer> and accept TreeNode root as input.

3. Final Answer:

   public List<Integer> rightSideView(TreeNode root) -> Option C

4. Quick Check:

   Return list of integers = public List<Integer> rightSideView(TreeNode root) [OK]

Hint: Return a list of node values, input is root node [OK]

Common Mistakes:

• Returning int instead of list
• Using void return type
• Incorrect parameter types

3. What is the output of the following code snippet for the right side view of the binary tree?

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

public List<Integer> rightSideView(TreeNode root) {
  List<Integer> result = new ArrayList<>();
  if (root == null) return result;
  Queue<TreeNode> queue = new LinkedList<>();
  queue.add(root);
  while (!queue.isEmpty()) {
    int size = queue.size();
    for (int i = 0; i < size; i++) {
      TreeNode node = queue.poll();
      if (node.left != null) queue.add(node.left);
      if (node.right != null) queue.add(node.right);
      if (i == size - 1) result.add(node.val);
    }
  }
  return result;
}

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

TreeNode 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);
System.out.println(rightSideView(root));

medium

A. [1, 2, 4]

B. [1, 2, 5]

C. [1, 3, 5]

D. [1, 3, 4]

Solution

1. Step 1: Traverse level by level and identify rightmost nodes

   Level 1: Node 1 (only node), Level 2: Nodes 2 and 3, rightmost is 3, Level 3: Nodes 5 and 4, rightmost is 4.

2. Step 2: Collect rightmost nodes in order

   Right side view list is [1, 3, 4].

3. Final Answer:

   [1, 3, 4] -> Option D

4. Quick Check:

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

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

Common Mistakes:

• Choosing leftmost nodes instead of rightmost
• Adding all nodes instead of only rightmost
• Confusing order of nodes

4. Identify the bug in the following code for computing the right side view of a binary tree:

public List<Integer> rightSideView(TreeNode root) {
  List<Integer> result = new ArrayList<>();
  if (root == null) return result;
  Queue<TreeNode> queue = new LinkedList<>();
  queue.add(root);
  while (!queue.isEmpty()) {
    int size = queue.size();
    for (int i = 0; i <= size; i++) {
      TreeNode node = queue.poll();
      if (node.left != null) queue.add(node.left);
      if (node.right != null) queue.add(node.right);
      if (i == size - 1) result.add(node.val);
    }
  }
  return result;
}

medium

A. The null check for root is missing

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

C. The queue should be a Stack instead of a Queue

D. The result list should be a Set to avoid duplicates

Solution

1. Step 1: Analyze the for loop condition

   The for loop runs from i = 0 to i <= size, which causes one extra iteration and poll from empty queue.

2. Step 2: Correct the loop boundary

   The loop should run i < size to process exactly 'size' nodes per level.

3. Final Answer:

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

4. Quick Check:

   Loop boundary off by one = The for loop condition should be i < size, not i <= size [OK]

Hint: Use i < size for loops over queue size [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Replacing queue with stack incorrectly
• Ignoring null root check
• Using Set instead of List unnecessarily

5. Given a binary tree, how would you modify the standard right side view algorithm to return the right side view in reverse order (bottom to top)?

hard

A. All of the above approaches can achieve the reverse right side view

B. Traverse the tree from bottom to top using recursion and add rightmost nodes

C. Use a stack to store rightmost nodes during BFS and pop them to reverse order

D. Collect rightmost nodes top to bottom, then reverse the list before returning

Solution

1. Step 1: Understand the standard right side view

   Standard approach collects rightmost nodes level by level from top to bottom.

2. Step 2: Consider ways to reverse order

   We can reverse the collected list, use recursion bottom-up, or use a stack to reverse order after BFS.

3. Step 3: Confirm all methods are valid

   Each method correctly produces the right side view in reverse order.

4. Final Answer:

   All of the above approaches can achieve the reverse right side view -> Option A

5. Quick Check:

   Multiple valid methods = All of the above approaches can achieve the reverse right side view [OK]

Hint: Reverse collected list or use stack/recursion [OK]

Common Mistakes:

• Thinking only one method works
• Ignoring simple list reversal
• Confusing traversal order