Right Side View of Binary Tree in DSA Python - 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 code that prints the right side view of a binary tree?

DSA Python

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def rightSideView(root):
    if not root:
        return []
    from collections import deque
    queue = deque([root])
    rightside = []
    while queue:
        level_length = len(queue)
        for i in range(level_length):
            node = queue.popleft()
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
            if i == level_length - 1:
                rightside.append(node.val)
    return rightside

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

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

print(rightSideView(root))

A [1, 2, 4]

B [1, 2, 5]

C [1, 3, 5]

D [1, 3, 4]

💡 Hint

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

The right side view includes the last node at each level when traversed from left to right. At level 1: 1, level 2: 3, level 3: 4.

🧠 Conceptual

intermediate

Understanding the Right Side View Concept

Which of the following best describes the right side view of a binary tree?

A Nodes visible when the tree is viewed from the right side, showing the rightmost node at each level.

B All leaf nodes of the binary tree.

C Nodes visible when the tree is viewed from the left side, showing the leftmost node at each level.

D All nodes at the deepest level of the binary tree.

💡 Hint

Think about which nodes you see if you stand on the right side of the tree.

The right side view shows the nodes that are the last visible nodes at each level when looking from the right side.

🔧 Debug

advanced

Identify the Error in Right Side View Implementation

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

DSA Python

def rightSideView(root):
    if root is None:
        return []
    queue = [root]
    rightside = []
    while queue:
        level_length = len(queue)
        for i in range(level_length):
            node = queue.pop()
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
            if i == level_length - 1:
                rightside.append(node.val)
    return rightside

A The code will raise a TypeError because queue is not a deque.

B The code will produce an incorrect right side view because queue.pop() removes from the end, causing incorrect traversal order.

C The code will raise an IndexError due to popping from an empty list.

D The code will produce the correct right side view output.

💡 Hint

Consider how popping from the end affects the order of nodes processed.

Using list.pop() removes the last element, which reverses the intended level order traversal, causing the wrong nodes to be processed and an incorrect right side view.

❓ Predict Output

advanced

Output of Right Side View for a Left-Skewed Tree

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

DSA Python

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def rightSideView(root):
    if not root:
        return []
    from collections import deque
    queue = deque([root])
    rightside = []
    while queue:
        level_length = len(queue)
        for i in range(level_length):
            node = queue.popleft()
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
            if i == level_length - 1:
                rightside.append(node.val)
    return rightside

# Tree structure:
#     1
#    /
#   2
#  /
# 3

root = TreeNode(1)
root.left = TreeNode(2)
root.left.left = TreeNode(3)

print(rightSideView(root))

A [1, 2, 3]

B [3]

C [1]

D [1, 3]

💡 Hint

Even if the tree leans left, the right side view shows the last node at each level.

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

🚀 Application

expert

Number of Nodes in Right Side View for a Complete Binary Tree

Given a complete binary tree with height h (root at height 1), how many nodes will the right side view contain?

A h - 1 (one less than the height)

B 2^h - 1 (all nodes in the tree)

C h (one node per level)

D 2^(h-1) (nodes in the last level only)

💡 Hint

The right side view shows exactly one node per level.

The right side view includes exactly one node from each level, so the count equals the height h.

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 views, this specifically shows the rightmost nodes 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 deepest level nodes only

2. Which of the following Python code snippets correctly initializes an empty list to store the right side view nodes?

easy

A. right_view = set()

B. right_view = []

C. right_view = ()

D. right_view = {}

Solution

1. Step 1: Identify the correct data structure for ordered collection

   We need a list to store nodes in order, so an empty list is initialized with [].

2. Step 2: Check other options

   {} is a dictionary, () is a tuple, set() is unordered; none fit the requirement.

3. Final Answer:

   right_view = [] -> Option B

4. Quick Check:

   Empty list uses [] [OK]

Hint: Use [] for empty list to store nodes [OK]

Common Mistakes:

• Using {} which creates a dictionary
• Using () which creates an empty tuple
• Using set() which is unordered

3. What is the output of the following code that prints the right side view of the binary tree?

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def rightSideView(root):
    if not root:
        return []
    from collections import deque
    queue = deque([root])
    right_view = []
    while queue:
        level_length = len(queue)
        for i in range(level_length):
            node = queue.popleft()
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
            if i == level_length - 1:
                right_view.append(node.val)
    return right_view

# Tree:
#     1
#    / \
#   2   3
#    \   \
#     5   4
root = TreeNode(1, TreeNode(2, None, TreeNode(5)), TreeNode(3, None, TreeNode(4)))
print(rightSideView(root))

medium

A. [1, 3, 4]

B. [1, 2, 5]

C. [1, 3, 5]

D. [1, 2, 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 A

4. Quick Check:

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

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

Common Mistakes:

• Picking leftmost node instead of rightmost
• Appending nodes before checking level end
• Confusing node values at each level

4. Find the error in the following code snippet for right side view and select the fix:

def rightSideView(root):
    if not root:
        return []
    queue = [root]
    right_view = []
    while queue:
        level_length = len(queue)
        for i in range(level_length):
            node = queue.pop()
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
            if i == level_length - 1:
                right_view.append(node.val)
    return right_view

medium

A. Remove the if condition checking i == level_length - 1

B. Replace queue.append(node.left) with queue.insert(0, node.left)

C. Initialize queue as a deque instead of list

D. Replace queue.pop() with queue.pop(0) to pop from front

Solution

1. Step 1: Identify queue operation error

   Using pop() removes last element, but BFS requires removing from front (FIFO).

2. Step 2: Fix by popping from front

   Use pop(0) to remove first element, maintaining correct BFS order.

3. Final Answer:

   Replace queue.pop() with queue.pop(0) to pop from front -> Option D

4. Quick Check:

   Queue pop front for BFS [OK]

Hint: Use pop(0) to dequeue from front in list-based BFS [OK]

Common Mistakes:

• Using pop() removes from end, breaking BFS order
• Appending children incorrectly
• Ignoring level length causing wrong node selection

5. Given a binary tree, how would you modify the right side view algorithm to return the left side view instead? Choose the best approach.

hard

A. Reverse the final right side view list before returning

B. Change the order of adding children to queue: add right child before left child

C. Change the order of adding children to queue: add left child before right child

D. Use a stack instead of a queue for traversal

Solution

1. Step 1: Understand right side view child addition order

   Right side view adds right child before left child to queue, so rightmost nodes appear last at each level.

2. Step 2: Modify to get left side view

   Change to add left child before right child so leftmost nodes appear last at each level and get recorded.

3. Final Answer:

   Change the order of adding children to queue: add left child before right child -> Option C

4. Quick Check:

   Left side view = add left child first [OK]

Hint: Add left child before right child for left side view [OK]

Common Mistakes:

• Reversing the right side view list incorrectly
• Adding right child before left child for left view
• Using stack breaks level order traversal