Right Side View of Binary Tree in DSA Rust - 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 right side view function for the given binary tree?

DSA Rust

struct TreeNode {
    val: i32,
    left: Option<Box<TreeNode>>,
    right: Option<Box<TreeNode>>,
}

fn right_side_view(root: Option<Box<TreeNode>>) -> Vec<i32> {
    use std::collections::VecDeque;
    let mut result = Vec::new();
    if root.is_none() {
        return result;
    }
    let mut queue = VecDeque::new();
    queue.push_back(root);
    while !queue.is_empty() {
        let level_size = queue.len();
        for i in 0..level_size {
            let node = queue.pop_front().unwrap();
            if let Some(n) = node {
                if i == level_size - 1 {
                    result.push(n.val);
                }
                if n.left.is_some() {
                    queue.push_back(n.left.clone());
                }
                if n.right.is_some() {
                    queue.push_back(n.right.clone());
                }
            }
        }
    }
    result
}

fn main() {
    let root = Some(Box::new(TreeNode {
        val: 1,
        left: Some(Box::new(TreeNode {
            val: 2,
            left: None,
            right: Some(Box::new(TreeNode {
                val: 5,
                left: None,
                right: None,
            })),
        })),
        right: Some(Box::new(TreeNode {
            val: 3,
            left: None,
            right: Some(Box::new(TreeNode {
                val: 4,
                left: None,
                right: None,
            })),
        })),
    }));
    let view = right_side_view(root);
    println!("{:?}", view);
}

A [1, 3, 4]

B [1, 2, 5]

C [1, 3, 5]

D [1, 2, 4]

💡 Hint

The right side view shows the last node visible at each level from the right side.

At level 1, node 1 is visible. At level 2, node 3 is the rightmost visible. At level 3, node 4 is the rightmost visible node.

🧠 Conceptual

intermediate

Understanding the Right Side View Concept

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

A It is the list of nodes visited in an in-order traversal.

B It is the list of nodes visible when the tree is viewed from the left side, showing the leftmost node at each level.

C It is the list of nodes visible when the tree is viewed from the right side, showing the rightmost node at each level.

D It is the list of all leaf nodes in the binary tree.

💡 Hint

Think about what nodes you see if you look at the tree from the right side.

The right side view includes the rightmost node at each depth level, as seen from the right side of the tree.

🔧 Debug

advanced

Identify the Error in Right Side View Implementation

What error will occur when running the following Rust code for right side view of a binary tree?

DSA Rust

fn right_side_view(root: Option<Box<TreeNode>>) -> Vec<i32> {
    use std::collections::VecDeque;
    let mut result = Vec::new();
    let mut queue = VecDeque::new();
    queue.push_back(root.unwrap());
    while !queue.is_empty() {
        let level_size = queue.len();
        for i in 0..level_size {
            let node = queue.pop_front().unwrap();
            if i == level_size - 1 {
                result.push(node.val);
            }
            if node.left.is_some() {
                queue.push_back(node.left.unwrap());
            }
            if node.right.is_some() {
                queue.push_back(node.right.unwrap());
            }
        }
    }
    result
}

A Panic at unwrap on empty Option if root is None

B Compilation error due to missing use of VecDeque

C Infinite loop because queue is never emptied

D No error, code runs correctly

💡 Hint

Check what happens if root is None and unwrap is called.

Calling unwrap on None causes a panic at runtime. The code does not check if root is None before unwrap.

❓ Predict Output

advanced

Output of Right Side View for Unbalanced Tree

What is the output of the right side view function for this unbalanced binary tree?

DSA Rust

let root = Some(Box::new(TreeNode {
    val: 10,
    left: Some(Box::new(TreeNode {
        val: 5,
        left: Some(Box::new(TreeNode {
            val: 3,
            left: None,
            right: None,
        })),
        right: None,
    })),
    right: Some(Box::new(TreeNode {
        val: 15,
        left: None,
        right: Some(Box::new(TreeNode {
            val: 20,
            left: None,
            right: None,
        })),
    })),
}));
let view = right_side_view(root);
println!("{:?}", view);

A [10, 15, 3]

B [10, 15, 20]

C [10, 5, 3]

D [10, 5, 20]

💡 Hint

The right side view shows the rightmost node at each level, even if the tree is unbalanced.

Level 1 rightmost is 10, level 2 rightmost is 15, level 3 rightmost is 20.

🚀 Application

expert

Number of Nodes in Right Side View for Complete Binary Tree of Height 4

How many nodes will be in the right side view of a complete binary tree with height 4?

A 8

B 7

C 15

D 4

💡 Hint

The right side view has one node per level visible from the right side.

A complete binary tree of height 4 has 4 levels, so the right side view has 4 nodes.

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 only.

2. Step 2: Differentiate from other views

   Unlike left side or leaf views, it only includes 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
• Including all leaf nodes instead of rightmost nodes
• Thinking it shows all nodes at the deepest level

2. Which Rust code snippet correctly declares a binary tree node struct for the right side view problem?

easy

A. struct TreeNode { val: i32, left: &TreeNode, right: &TreeNode }

B. struct TreeNode { val: i32, left: Option, right: Option }

C. struct TreeNode { val: i32, left: TreeNode, right: TreeNode }

D. struct TreeNode { val: i32, left: Option<TreeNode>, right: Option<TreeNode> }

Solution

1. Step 1: Check ownership and optional children

   Rust needs Option for nullable child nodes with ownership.

2. Step 2: Validate correct struct syntax

   Option allows recursive tree structure safely.

3. Final Answer:

   struct TreeNode { val: i32, left: Option, right: Option } -> Option B

4. Quick Check:

   Use Option for children [OK]

Hint: Use Option for nullable child nodes [OK]

Common Mistakes:

• Using direct TreeNode type causing infinite size error
• Using references without lifetimes
• Using Option<TreeNode> without Box causing compile error

3. What is the output of the right side view function for this tree?

    1
   / \
  2   3
   \   \
    5   4

Assuming the function returns a vector of node values visible from the right side.

medium

A. [1, 2, 4]

B. [1, 2, 5]

C. [1, 3, 4]

D. [1, 3, 5]

Solution

1. Step 1: Identify rightmost nodes at each level

   Level 0: 1, Level 1: 3 (right child), Level 2: 4 (right child of 3)

2. Step 2: Collect these nodes in order

   Right side view vector is [1, 3, 4]

3. Final Answer:

   [1, 3, 4] -> Option C

4. Quick Check:

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

Hint: Pick rightmost node at each tree level [OK]

Common Mistakes:

• Choosing left child nodes instead of rightmost
• Including nodes not visible from right side
• Mixing order of nodes in output

4. Given this Rust function snippet for right side view, what is the bug?

fn right_side_view(root: Option) -> Vec<i32> {
    let mut result = Vec::new();
    let mut queue = Vec::new();
    if root.is_some() {
        queue.push(root.unwrap());
    }
    while !queue.is_empty() {
        let level_size = queue.len();
        for i in 0..level_size {
            let node = queue.remove(0);
            if i == level_size - 1 {
                result.push(node.val);
            }
            if node.left.is_some() {
                queue.push(node.left.unwrap());
            }
            if node.right.is_some() {
                queue.push(node.right.unwrap());
            }
        }
    }
    result
}

medium

A. The function returns the left side view, not right side

B. Queue should be a linked list, not a vector

C. The loop should iterate backwards

D. Using unwrap() consumes the Option, causing ownership errors

Solution

1. Step 1: Analyze use of unwrap() on Option

   Calling unwrap() moves the value out, so subsequent uses cause ownership errors.

2. Step 2: Identify correct approach

   Use references or cloning to avoid moving ownership when pushing children into queue.

3. Final Answer:

   Using unwrap() consumes the Option, causing ownership errors -> Option D

4. Quick Check:

   unwrap() moves ownership, causing errors [OK]

Hint: Avoid unwrap() that moves ownership inside loops [OK]

Common Mistakes:

• Ignoring ownership rules in Rust
• Thinking vector is wrong data structure here
• Misunderstanding loop direction relevance

5. How would you modify a standard level order traversal in Rust to return the right side view of a binary tree efficiently?

hard

A. Traverse each level left to right, record last node's value per level

B. Traverse each level right to left, record first node's value per level

C. Traverse each level left to right, record first node's value per level

D. Traverse each level right to left, record last node's value per level

Solution

1. Step 1: Understand level order traversal direction

   Standard level order goes left to right per level.

2. Step 2: Identify which node to record

   Recording the last node at each level gives the rightmost visible node.

3. Final Answer:

   Traverse each level left to right, record last node's value per level -> Option A

4. Quick Check:

   Last node per level in left-to-right traversal = right side view [OK]

Hint: Record last node at each level in left-to-right traversal [OK]

Common Mistakes:

• Recording first node instead of last
• Changing traversal direction unnecessarily
• Confusing left and right side views