Right Side View of Binary Tree in DSA Javascript - Execution Trace

Concept Flow - Right Side View of Binary Tree

Start at root node

↓

Initialize queue with root

↓

While queue not empty

↓

Process all nodes at current level

↓

For each node: enqueue left child if exists

↓

For each node: enqueue right child if exists

↓

Record last node value of this level

↓

Repeat for next level

↓

Return collected right side view values

We start from the root and use a queue to visit nodes level by level. At each level, we record the last node's value, which is visible from the right side.

Execution Sample

DSA Javascript

function rightSideView(root) {
  if (!root) return [];
  const queue = [root];
  const result = [];
  while (queue.length) {
    let size = queue.length;
    for (let i = 0; i < size; i++) {
      const node = queue.shift();
      if (node.left) queue.push(node.left);
      if (node.right) queue.push(node.right);
      if (i === size - 1) result.push(node.val);
    }
  }
  return result;
}

This code collects the rightmost node's value at each level of the binary tree using a breadth-first search.

Execution Table

Step	Operation	Node Visited	Queue State	Right Side View Collected	Visual Tree State
1	Initialize queue with root	1	[1]	[]	1 / \ 2 3 / \ 4 5
2	Process level 1 (size=1)	1	[]	[1]	1 / \ 2 3 / \ 4 5
3	Enqueue children of node 1	1	[2, 3]	[1]	1 / \ 2 3 / \ 4 5
4	Process level 2 (size=2)	2	[3]	[1]	1 / \ 2 3 / \ 4 5
5	Enqueue children of node 2	2	[3, 4]	[1]	1 / \ 2 3 / \ 4 5
6	Process level 2 (continued)	3	[4]	[1, 3]	1 / \ 2 3 / \ 4 5
7	Enqueue children of node 3	3	[4, 5]	[1, 3]	1 / \ 2 3 / \ 4 5
8	Process level 3 (size=2)	4	[5]	[1, 3]	1 / \ 2 3 / \ 4 5
9	Node 4 has no children to enqueue	4	[5]	[1, 3]	1 / \ 2 3 / \ 4 5
10	Process level 3 (continued)	5	[]	[1, 3, 5]	1 / \ 2 3 / \ 4 5
11	Node 5 has no children to enqueue	5	[]	[1, 3, 5]	1 / \ 2 3 / \ 4 5
12	Queue empty, end	-	[]	[1, 3, 5]	1 / \ 2 3 / \ 4 5

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

Variable Tracker

Variable	Start	After Step 2	After Step 6	After Step 10	Final
queue	[1]	[]	[4]	[]	[]
result	[]	[1]	[1,3]	[1,3,5]	[1,3,5]
size	-	1	2	2	-
node visited	-	1	3	5	-

Key Moments - 3 Insights

Why do we record the last node's value at each level?

Because the last node visited at each level is the one visible from the right side. See execution_table rows 2, 6, and 10 where the right side view is updated.

Why do we enqueue left child before right child if we want the right side view?

We enqueue left then right to maintain normal level order traversal. The last node processed at each level is the rightmost node, which we record. See execution_table rows 3 and 7.

What happens when the queue becomes empty?

It means all nodes have been processed and the right side view is complete. See execution_table row 12 where the queue is empty and the algorithm ends.

Visual Quiz - 3 Questions

Look at the execution_table at step 6, what is the right side view collected so far?

A [1, 2]

B [1]

C [1, 3]

D []

💡 Hint

Check the 'Right Side View Collected' column at step 6 in the execution_table.

At which step does the queue become empty?

A Step 12

B Step 8

C Step 10

D Step 6

💡 Hint

Look at the 'Queue State' column in the execution_table to find when it is [].

If we changed the tree so node 3 had no right child, what would be the last value added to the right side view?

A 5

B 4

C 3

D 2

💡 Hint

Consider the last node visited at the last level in the modified tree, referencing the visual tree state.

Concept Snapshot

Right Side View of Binary Tree:
- Use level order traversal (BFS) with a queue
- At each level, record the last node's value
- Enqueue left then right children
- Continue until queue is empty
- Result is list of rightmost nodes per level

Full Transcript

The right side view of a binary tree is found by visiting nodes level by level from left to right and recording the last node at each level. We start with the root in a queue. While the queue is not empty, we process all nodes at the current level. For each node, we add its children to the queue, left child first then right child. After processing a level, we record the last node's value seen at that level. We repeat this until all levels are processed and the queue is empty. The collected values form the right side view of the tree.