Left Side View of Binary Tree in DSA Typescript - 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 at this level

↓

Dequeue node

↓

Enqueue left child if exists

↓

Enqueue right child if exists

↓

Repeat for next level

↓

Return collected left side 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 encountered as part of the left side view.

Execution Sample

DSA Typescript

function leftSideView(root: TreeNode | null): number[] {
  if (!root) return [];
  const queue = [root];
  const leftView = [];
  while (queue.length) {
    const levelSize = queue.length;
    for (let i = 0; i < levelSize; i++) {
      const node = queue.shift()!;
      if (i === 0) leftView.push(node.val);
      if (node.left) queue.push(node.left);
      if (node.right) queue.push(node.right);
    }
  }
  return leftView;
}

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

Execution Table

Step	Operation	Node Visited	Queue State	Left View Collected	Visual State
1	Initialize queue with root	1	[1]	[]	1 / \ 2 3 / \ 4 5
2	Start level traversal, levelSize=1	1	[1]	[]	1 / \ 2 3 / \ 4 5
3	Visit first node at level, add to left view	1	[]	[1]	1 / \ 2 3 / \ 4 5
4	Enqueue left child of 1	1	[2]	[1]	1 / \ 2 3 / \ 4 5
5	Enqueue right child of 1	1	[2,3]	[1]	1 / \ 2 3 / \ 4 5
6	Start level traversal, levelSize=2	2	[2,3]	[1]	1 / \ 2 3 / \ 4 5
7	Visit first node at level, add to left view	2	[3]	[1,2]	1 / \ 2 3 / \ 4 5
8	Enqueue left child of 2	2	[3,4]	[1,2]	1 / \ 2 3 / \ 4 5
9	No right child of 2	2	[3,4]	[1,2]	1 / \ 2 3 / \ 4 5
10	Visit next node at level	3	[4]	[1,2]	1 / \ 2 3 / \ 4 5
11	No left child of 3	3	[4]	[1,2]	1 / \ 2 3 / \ 4 5
12	Enqueue right child of 3	3	[4,5]	[1,2]	1 / \ 2 3 / \ 4 5
13	Start level traversal, levelSize=2	4	[4,5]	[1,2]	1 / \ 2 3 / \ 4 5
14	Visit first node at level, add to left view	4	[5]	[1,2,4]	1 / \ 2 3 / \ 4 5
15	No left child of 4	4	[5]	[1,2,4]	1 / \ 2 3 / \ 4 5
16	No right child of 4	4	[5]	[1,2,4]	1 / \ 2 3 / \ 4 5
17	Visit next node at level	5	[]	[1,2,4]	1 / \ 2 3 / \ 4 5
18	No left child of 5	5	[]	[1,2,4]	1 / \ 2 3 / \ 4 5
19	No right child of 5	5	[]	[1,2,4]	1 / \ 2 3 / \ 4 5
20	Queue empty, traversal ends	-	[]	[1,2,4]	1 / \ 2 3 / \ 4 5

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

Variable Tracker

Variable	Start	After Step 4	After Step 6	After Step 13	Final
queue	[1]	[2]	[2,3]	[4,5]	[]
leftView	[]	[1]	[1]	[1,2]	[1,2,4]
levelSize	-	1	2	2	-

Key Moments - 3 Insights

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

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

Why do we use a queue for traversal?

A queue helps us visit nodes level by level (breadth-first). This ensures we process all nodes at one level before moving to the next, as seen in the queue state changes in execution_table.

What happens if the tree is empty?

The function returns an empty array immediately (see execution_sample code line 2). No traversal happens and leftView remains empty.

Visual Quiz - 3 Questions

Look at the execution_table, what is the leftView collected after visiting node 2 at step 7?

A []

B [1]

C [1,2]

D [1,2,4]

💡 Hint

Check the 'Left View Collected' column at step 7 in execution_table

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

A Step 17

B Step 20

C Step 19

D Step 13

💡 Hint

Look for the step where 'Queue State' is empty and operation notes traversal ends

If node 2 had a right child, how would the queue state change after step 8?

A Queue would include the right child after node 4

B Queue would remain the same as [3,4]

C Queue would only have the right child

D Queue would be empty

💡 Hint

Refer to steps 4 and 5 where children are enqueued after visiting a node

Concept Snapshot

Left Side View of Binary Tree:
- Use level order traversal with a queue
- For each level, record the first node visited
- Enqueue left then right children
- Continue until queue is empty
- Result is nodes visible from left side

Full Transcript

This visualization shows how 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, the first node visited is added to the left view list. We enqueue children left first, then right, to ensure leftmost nodes come first. The process repeats until all nodes are visited and the queue is empty. The final left view contains the nodes visible from the left side of the tree.