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

Left Side View of Binary Tree

📖 Scenario: You are working with a simple binary tree that represents a family tree. You want to see the names of family members visible from the left side of the tree.

🎯 Goal: Build a program that creates a binary tree, then finds and prints the left side view of the tree. The left side view shows the first node visible at each level when looking from the left.

📋 What You'll Learn

Create a binary tree with given nodes and structure

Use a variable to track the current level during traversal

Implement a function to collect the left side view nodes

Print the left side view nodes in order

💡 Why This Matters

🌍 Real World

Left side view of a binary tree helps in understanding hierarchical data from a specific perspective, useful in family trees, organizational charts, and file systems.

💼 Career

Understanding tree traversal and views is important for software engineers working with hierarchical data structures, UI rendering, and algorithms.

1

Create the Binary Tree Nodes

Create a class called Node with an __init__ method that takes name, left, and right parameters. Then create the following nodes exactly: root = Node('Grandparent'), root.left = Node('Parent1'), root.right = Node('Parent2'), root.left.left = Node('Child1'), root.left.right = Node('Child2'), root.right.right = Node('Child3').

DSA Python

# Define Node class and create the binary tree nodes as described
# Your code here

Hint

Define the Node class first, then create the nodes exactly as given.

2

Add a Variable to Track Levels

Create a variable called max_level and set it to -1. This will help track the deepest level visited so far during traversal.

DSA Python

class Node:
    def __init__(self, name, left=None, right=None):
        self.name = name
        self.left = left
        self.right = right

root = Node('Grandparent')
root.left = Node('Parent1')
root.right = Node('Parent2')
root.left.left = Node('Child1')
root.left.right = Node('Child2')
root.right.right = Node('Child3')

# Create max_level variable and set to -1
# Your code here

Hint

Just create a variable named max_level and assign it -1.

3

Implement Left Side View Function

Define a function called left_side_view that takes node, level, max_level, and result as parameters. Use recursion to visit nodes. If node is None, return. If level is greater than max_level[0], append node.name to result and update max_level[0] to level. Then recursively call left_side_view for node.left and node.right with level + 1. Initialize max_level as a list with one element -1 to allow modification inside the function.

DSA Python

class Node:
    def __init__(self, name, left=None, right=None):
        self.name = name
        self.left = left
        self.right = right

root = Node('Grandparent')
root.left = Node('Parent1')
root.right = Node('Parent2')
root.left.left = Node('Child1')
root.left.right = Node('Child2')
root.right.right = Node('Child3')

max_level = -1

# Define left_side_view function as described
# Your code here

Hint

Use recursion and check if the current level is greater than the max level seen so far. Use a list for max_level to allow updates inside the function.

4

Print the Left Side View

Create an empty list called result. Call left_side_view(root, 0, max_level, result). Then print the result list.

DSA Python

class Node:
    def __init__(self, name, left=None, right=None):
        self.name = name
        self.left = left
        self.right = right

root = Node('Grandparent')
root.left = Node('Parent1')
root.right = Node('Parent2')
root.left.left = Node('Child1')
root.left.right = Node('Child2')
root.right.right = Node('Child3')

max_level = [-1]

def left_side_view(node, level, max_level, result):
    if node is None:
        return
    if level > max_level[0]:
        result.append(node.name)
        max_level[0] = level
    left_side_view(node.left, level + 1, max_level, result)
    left_side_view(node.right, level + 1, max_level, result)

# Create result list, call left_side_view, and print result
# Your code here

Hint

Remember to create the result list before calling the function and print it after.

Practice

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

easy

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

B. Nodes at the deepest level of the tree

C. All leaf nodes of the tree

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

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 D

4. Quick Check:

   Left side view = nodes visible from left [OK]

Hint: Left side view shows first node at each level from left [OK]

Common Mistakes:

• Confusing left side view with right side view
• Thinking it shows all leaf nodes
• Assuming it shows deepest nodes only

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

easy

A. left_view = ()

B. left_view = {}

C. left_view = []

D. left_view = set()

Solution

1. Step 1: Identify the correct data structure

   We need a list to store nodes in order, so an empty list is best.

2. Step 2: Check syntax for list initialization

   Using square brackets [] creates an empty list in Python.

3. Final Answer:

   left_view = [] -> Option C

4. Quick Check:

   Empty list = [] [OK]

Hint: Use [] to create empty list for ordered nodes [OK]

Common Mistakes:

• Using {} which creates a dictionary, not a list
• Using () which creates a tuple, not a list
• Using set() which is unordered

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

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

def left_side_view(root):
    result = []
    def dfs(node, level):
        if not node:
            return
        if level == len(result):
            result.append(node.val)
        dfs(node.left, level + 1)
        dfs(node.right, level + 1)
    dfs(root, 0)
    return result

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

print(left_side_view(root))

medium

A. [1, 2, 3]

B. [1, 2, 4]

C. [1, 3, 5]

D. [1, 4, 5]

Solution

1. Step 1: Trace DFS traversal and level checks

   At level 0, node 1 is added. At level 1, node 2 is added (left child). At level 2, node 4 is added (left child's right child).

2. Step 2: Confirm nodes added only once per level

   Right children at each level are ignored if left child exists at that level.

3. Final Answer:

   [1, 2, 4] -> Option B

4. Quick Check:

   Left side view nodes = [1, 2, 4] [OK]

Hint: Add node if level equals result length during DFS [OK]

Common Mistakes:

• Adding right child nodes before left child nodes
• Appending nodes multiple times per level
• Confusing left and right children order

4. Find the error in the following code that attempts to print the left side view of a binary tree:

def left_side_view(root):
    result = []
    def dfs(node, level):
        if node is None:
            return
        if level < len(result):
            result.append(node.val)
        dfs(node.left, level + 1)
        dfs(node.right, level + 1)
    dfs(root, 0)
    return result

medium

A. The condition should be 'level == len(result)', not 'level < len(result)'

B. The base case should check 'if node' instead of 'if node is None'

C. The recursive calls should swap left and right children

D. The function should return 'result' inside the dfs function

Solution

1. Step 1: Analyze the condition for adding nodes

   The code uses 'level < len(result)' which is incorrect because nodes should be added only when level equals the current result length.

2. Step 2: Correct the condition to add nodes once per level

   Changing condition to 'level == len(result)' ensures only the first node at each level is added.

3. Final Answer:

   The condition should be 'level == len(result)', not 'level < len(result)' -> Option A

4. Quick Check:

   Use '==' to add first node per level [OK]

Hint: Add node only when level equals result length [OK]

Common Mistakes:

• Using '<' instead of '==' in condition
• Returning result inside recursive function
• Swapping left and right child calls unnecessarily

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

hard

A. Perform the usual left side view traversal, then reverse the result list before returning

B. Traverse the tree from right to left instead of left to right

C. Add nodes to the result list only if they are leaf nodes

D. Use a queue and perform level order traversal from right to left

Solution

1. Step 1: Perform standard left side view traversal

   Use DFS or BFS to collect the first node at each level from left to right.

2. Step 2: Reverse the collected list

   After traversal, reverse the list to get nodes from bottom to top.

3. Final Answer:

   Perform the usual left side view traversal, then reverse the result list before returning -> Option A

4. Quick Check:

   Reverse after left side view traversal [OK]

Hint: Reverse the left side view list after traversal [OK]

Common Mistakes:

• Changing traversal order instead of reversing result
• Collecting leaf nodes only
• Using right to left traversal which gives wrong nodes