Left Side View of Binary Tree in DSA Rust - Build from Scratch

Left Side View of Binary Tree

📖 Scenario: You are working with a binary tree that represents a family tree. You want to see the family members visible from the left side, like looking at the tree from the left.

🎯 Goal: Build a Rust program that creates a binary tree, sets a depth limit, finds the left side view of the tree up to that depth, and prints the visible nodes.

📋 What You'll Learn

Create a binary tree with exact nodes and structure

Add a variable for maximum depth to view

Implement a function to find the left side view of the tree

Print the left side view nodes in order

💡 Why This Matters

🌍 Real World

Viewing the left side of a tree structure helps in visualizing hierarchical data from a specific perspective, useful in family trees, organizational charts, or file systems.

💼 Career

Understanding tree traversal and views is important for software engineers working with data structures, UI trees, and algorithms that require selective data visibility.

1

Create the Binary Tree Structure

Define a binary tree node struct called TreeNode with val as i32, and left and right as Option>. Then create a variable root representing this tree:

1
/ \
2 3
/ \
4 5

Use exact values and structure.

DSA Rust

// Define TreeNode struct and create the root node with given structure
// Your code here

Hint

Use Option> for left and right children to allow empty branches.

2

Add Maximum Depth Variable

Add a variable called max_depth of type usize and set it to 3. This will limit how deep we look into the tree.

DSA Rust

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

fn main() {
    let root = Some(Box::new(TreeNode {
        val: 1,
        left: Some(Box::new(TreeNode {
            val: 2,
            left: Some(Box::new(TreeNode {
                val: 4,
                left: None,
                right: None,
            })),
            right: None,
        })),
        right: Some(Box::new(TreeNode {
            val: 3,
            left: None,
            right: Some(Box::new(TreeNode {
                val: 5,
                left: None,
                right: None,
            })),
        })),
    }));
    // Add max_depth variable here
    // Your code here
}

Hint

Use let max_depth: usize = 3; inside main.

3

Implement Left Side View Function

Write a function called left_side_view that takes root: &Option> and max_depth: usize and returns a Vec of node values visible from the left side up to max_depth. Use a helper function with parameters node, depth, and result to do a depth-first search. Add nodes to result only if depth is less than max_depth and the current depth is the first time visiting that level.

DSA Rust

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

fn left_side_view(root: &Option>, max_depth: usize) -> Vec {
    // Your code here
}

fn main() {
    let root = Some(Box::new(TreeNode {
        val: 1,
        left: Some(Box::new(TreeNode {
            val: 2,
            left: Some(Box::new(TreeNode {
                val: 4,
                left: None,
                right: None,
            })),
            right: None,
        })),
        right: Some(Box::new(TreeNode {
            val: 3,
            left: None,
            right: Some(Box::new(TreeNode {
                val: 5,
                left: None,
                right: None,
            })),
        })),
    }));
    let max_depth: usize = 3;
}

Hint

Use a helper function to do a depth-first search. Add the node value to result only if the current depth equals the length of result, meaning it's the first node at this depth.

4

Print the Left Side View

Call the left_side_view function with root and max_depth, store the result in visible_nodes, and print it using println!("{:?}", visible_nodes);.

DSA Rust

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

fn left_side_view(root: &Option>, max_depth: usize) -> Vec {
    fn helper(node: &Option>, depth: usize, max_depth: usize, result: &mut Vec) {
        if let Some(n) = node {
            if depth < max_depth && depth == result.len() {
                result.push(n.val);
            }
            helper(&n.left, depth + 1, max_depth, result);
            helper(&n.right, depth + 1, max_depth, result);
        }
    }
    let mut result = Vec::new();
    helper(root, 0, max_depth, &mut result);
    result
}

fn main() {
    let root = Some(Box::new(TreeNode {
        val: 1,
        left: Some(Box::new(TreeNode {
            val: 2,
            left: Some(Box::new(TreeNode {
                val: 4,
                left: None,
                right: None,
            })),
            right: None,
        })),
        right: Some(Box::new(TreeNode {
            val: 3,
            left: None,
            right: Some(Box::new(TreeNode {
                val: 5,
                left: None,
                right: None,
            })),
        })),
    }));
    let max_depth: usize = 3;
    // Print the left side view here
    // Your code here
}

Hint

Call left_side_view(&root, max_depth), save to visible_nodes, then print with println!("{:?}", visible_nodes);.

Practice

1. What does the Left Side View of a binary tree represent?

easy

A. All leaf nodes of the tree

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

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

D. Nodes at the deepest level of the tree

Solution

1. Step 1: Understand the view perspective

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

2. Step 2: Identify visible nodes

   Only the first node at each level from the left is visible in this view.

3. Final Answer:

   Nodes visible when the tree is viewed from the left side -> Option C

4. Quick Check:

   Left side view = nodes seen from left [OK]

Hint: Think of standing on the left side and looking at the tree [OK]

Common Mistakes:

• Confusing left side view with right side view
• Including all leaf nodes instead of first nodes per level
• Thinking it shows deepest nodes only

2. Which Rust code snippet correctly declares a binary tree node struct for left side view traversal?

easy

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

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

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

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

Solution

1. Step 1: Check ownership and optional children

   Rust binary trees use Option for nullable child nodes.

2. Step 2: Validate correct syntax

   Option allows for null or Some(child), which is correct for left and right.

3. Final Answer:

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

4. Quick Check:

   Use Option for nullable children [OK]

Hint: Use Option for child nodes in Rust [OK]

Common Mistakes:

• Using direct TreeNode type for children (causes infinite size)
• Using references without lifetimes
• Omitting Option for nullable children

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

    1
   / \
  2   3
   \   \
    5   4

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

medium

A. [1, 3, 4]

B. [1, 2, 5]

C. [1, 2, 4]

D. [1, 5, 4]

Solution

1. Step 1: Identify nodes visible from left at each level

   Level 0: 1, Level 1: 2 (left child), Level 2: 5 (right child of 2)

2. Step 2: Collect visible nodes in order

   Left side view nodes are [1, 2, 5]

3. Final Answer:

   [1, 2, 5] -> Option B

4. Quick Check:

   Left side nodes = [1, 2, 5] [OK]

Hint: Pick first node at each level from left [OK]

Common Mistakes:

• Choosing right child nodes instead of left
• Including nodes not visible from left
• Mixing order of nodes

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

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

medium

A. Calling unwrap() on root without checking if it is null

B. Using remove(0) on vector causes runtime error

C. Pushing right child before left child breaks left view order

D. Not returning the result vector at the end

Solution

1. Step 1: Check root unwrap usage

   Calling unwrap() on root without checking if it is null can cause panic if tree is empty.

2. Step 2: Confirm other parts are correct

   remove(0) works but is inefficient; order of pushing left then right is correct; result is returned.

3. Final Answer:

   Calling unwrap() on root without checking if it is null -> Option A

4. Quick Check:

   unwrap() on null causes panic [OK]

Hint: Check unwrap() calls for null before use [OK]

Common Mistakes:

• Ignoring unwrap panic possibility
• Thinking remove(0) causes error (just slow)
• Confusing child push order
• Missing return statement

5. You want to modify the left side view function to return the leftmost node values only for levels where the node value is even. Which approach is correct?

hard

A. Add a check inside the level loop: if i == 0 and node.val % 2 == 0, then push node.val to result

B. Push node.val for all nodes during traversal, then filter even values from result after traversal

C. Push node.val only if node.val is even, ignoring position in level

D. Push node.val if it is even and it is the rightmost node at the level

Solution

1. Step 1: Understand requirement for leftmost even nodes

   We want only the first node at each level if its value is even.

2. Step 2: Apply condition during traversal

   Check if i == 0 (leftmost) and node.val % 2 == 0 before pushing to result.

3. Final Answer:

   Add a check inside the level loop: if i == 0 and node.val % 2 == 0, then push node.val to result -> Option A

4. Quick Check:

   Filter leftmost nodes by even value during traversal [OK]

Hint: Check leftmost and even condition together inside loop [OK]

Common Mistakes:

• Filtering after traversal loses position info
• Ignoring leftmost position and filtering only by value
• Checking rightmost node instead of leftmost