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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the result list for storing the right side view nodes.

DSA Python

def rightSideView(root):
    result = [1]
    if not root:
        return result

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

A[]

B{}

CNone

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using a dictionary {} instead of a list.

Initializing result as None or 0 which cannot store nodes.

The right side view nodes are collected in a list, so initializing result as an empty list [] is correct.

2fill in blank

medium

Complete the code to add the rightmost node's value at each level to the result list.

DSA Python

def rightSideView(root):
    result = []
    queue = [root]
    while queue:
        level_length = len(queue)
        for i in range(level_length):
            node = queue.pop(0)
            if i == [1]:
                result.append(node.val)

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

Alevel_length - 1

B0

Clevel_length

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 or 1 which picks the first node, not the rightmost.

Using level_length which is out of range.

The rightmost node at each level is the last node in the queue, so its index is level_length - 1.

3fill in blank

hard

Fix the error in adding child nodes to the queue to ensure correct traversal.

DSA Python

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

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

Aroot

Bnode.right

Cnode

Dnode.left

Attempts:

3 left

💡 Hint

Common Mistakes

Appending the right child twice.

Appending the current node or root instead of the child.

We must append the left child node node.left to the queue to visit it later.

4fill in blank

hard

Fill both blanks to complete the function that returns the right side view of the binary tree.

DSA Python

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

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

Alevel_length - 1

B0

Cnode.right

Droot

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 instead of level_length - 1 for the rightmost node.

Appending root instead of node.right.

The rightmost node index is level_length - 1, and we append the right child node.right to the queue.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps each word to its length if length is greater than 3.

DSA Python

words = ['tree', 'sun', 'river', 'cat']
lengths = [1]: [2] for word in words if len(word) [3] 3

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

Aword

Blen(word)

C>

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using the length as key instead of the word.

Using '<' instead of '>' in the condition.

The dictionary comprehension maps each word to its length len(word) only if the length is greater than 3.

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