Left Side View of Binary Tree in DSA Go - Execution Trace

Concept Flow - Left Side View of Binary Tree

Start at root node

↓

Initialize queue with root

↓

While queue not empty

↓

Get number of nodes at current level

↓

For each node in level

↓

Pop node

↓

Add left child to queue if exists

↓

Add right child to queue if exists

↓

Repeat for next level

↓

End when queue empty

↓

Return collected left view nodes

We start from the root and use a queue to traverse the tree level by level. For each level, we record the first node seen as part of the left side view.

Execution Sample

DSA Go

func leftSideView(root *TreeNode) []int {
    if root == nil {
        return []int{}
    }
    queue := []*TreeNode{root}
    var result []int
    for len(queue) > 0 {
        levelSize := len(queue)
        for i := 0; i < levelSize; i++ {
            node := queue[0]
            queue = queue[1:]
            if i == 0 {
                result = append(result, node.Val)
            }
            if node.Left != nil {
                queue = append(queue, node.Left)
            }
            if node.Right != nil {
                queue = append(queue, node.Right)
            }
        }
    }
    return result
}

This code collects the left side view nodes of a binary tree using level order traversal.

Execution Table

Step	Operation	Nodes in Queue	Pointer Changes	Visual State (Tree + Left View)
1	Initialize queue with root (1)	[1]	queue = [1]	Tree: 1 Left View: []
2	Start level 1, levelSize=1	[1]	levelSize=1	Tree: 1 Left View: []
3	Pop node 1 (first in level)	[]	queue=[]	Tree: 1 Left View: [1]
4	Add left child 2 to queue	[2]	queue=[2]	Tree: 1 Left View: [1]
5	Add right child 3 to queue	[2,3]	queue=[2,3]	Tree: 1 Left View: [1]
6	Start level 2, levelSize=2	[2,3]	levelSize=2	Tree: 1 Left View: [1]
7	Pop node 2 (first in level)	[3]	queue=[3]	Tree: 1 Left View: [1,2]
8	Add left child 4 to queue	[3,4]	queue=[3,4]	Tree: 1 Left View: [1,2]
9	Add right child 5 to queue	[3,4,5]	queue=[3,4,5]	Tree: 1 Left View: [1,2]
10	Pop node 3 (second in level)	[4,5]	queue=[4,5]	Tree: 1 Left View: [1,2]
11	No children to add	[4,5]	queue=[4,5]	Tree: 1 Left View: [1,2]
12	Start level 3, levelSize=2	[4,5]	levelSize=2	Tree: 1 Left View: [1,2]
13	Pop node 4 (first in level)	[5]	queue=[5]	Tree: 1 Left View: [1,2,4]
14	No children to add	[5]	queue=[5]	Tree: 1 Left View: [1,2,4]
15	Pop node 5 (second in level)	[]	queue=[]	Tree: 1 Left View: [1,2,4]
16	No children to add	[]	queue=[]	Tree: 1 Left View: [1,2,4]
17	Queue empty, end traversal	[]	queue=[]	Tree: 1 Left View: [1,2,4]

💡 Queue is empty, all levels processed, left view collected

Variable Tracker

Variable	Start	After Step 1	After Step 5	After Step 10	After Step 15	Final
queue	[]	[1]	[2,3]	[4,5]	[]	[]
levelSize	0	1	2	2	0	0
result (left view)	[]	[]	[1]	[1,2]	[1,2,4]	[1,2,4]

Key Moments - 3 Insights

Why do we add only the first node of each level to the left view?

Because the first node at each level is the leftmost node visible from the left side. This is shown in execution_table rows 3, 7, and 13 where the first node popped at each level is added to the left view.

Why do we use a queue to traverse the tree?

A queue helps us process nodes level by level (breadth-first). This ensures we see nodes in order from left to right at each level, as shown in the queue states in execution_table rows 1, 5, 10, and 15.

What happens if the tree is empty?

If the root is nil, the function returns an empty list immediately, so no traversal happens. This is the start condition before step 1.

Visual Quiz - 3 Questions

Look at the execution_table at step 7. What is the left view after popping node 2?

A [1]

B [1, 2]

C [1, 3]

D [2]

💡 Hint

Check the 'Visual State' column at step 7 in execution_table.

At which step does the queue become empty, ending the traversal?

A Step 17

B Step 15

C Step 10

D Step 5

💡 Hint

Look for the step where 'Queue empty, end traversal' is noted in execution_table.

If the tree had no right children, how would the queue state change at step 5?

A [2, 3]

B [3]

C [2]

D []

💡 Hint

At step 5, right child 3 is added to queue; if no right child, it won't be added.

Concept Snapshot

Left Side View of Binary Tree:
- Use level order traversal with a queue
- For each level, add the first node to the left view
- Traverse until queue is empty
- Return collected nodes as left side view
- Handles empty tree by returning empty list

Full Transcript

To find the left side view of a binary tree, we start at the root and use a queue to visit nodes level by level. At each level, we record the first node we see because it is the leftmost node visible from the left side. We add the left and right children of each node to the queue to process the next level. This continues until the queue is empty, meaning all nodes have been visited. If the tree is empty, we return an empty list immediately. The left view is the list of first nodes from each level.