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

Concept Flow - Right Side View of Binary Tree

Start at root node

↓

Use queue for level order traversal

↓

For each level:

↓

Traverse nodes left to right

↓

Record last node of level (rightmost)

↓

Add children to queue

↓

Repeat until queue empty

↓

Return list of recorded nodes

We visit the tree level by level from left to right, recording the last node at each level to get the right side view.

Execution Sample

DSA Go

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

This code collects the rightmost node at each level of the binary tree using a queue for level order traversal.

Execution Table

Step	Operation	Node Visited	Queue State	Rightmost Node This Level	Right Side View So Far
1	Start with root	1	[1]	None	[]
2	Process level size=1	1	[]	1	[1]
3	Add children of 1	1	[2,3]	1	[1]
4	Process level size=2	2	[3]	2	[1]
5	Add children of 2	2	[3,5]	2	[1]
6	Process level size=1	3	[5,4]	3	[1,3]
7	Add children of 3	3	[5,4]	3	[1,3]
8	Process level size=2	5	[4]	5	[1,3]
9	Add children of 5	5	[4]	5	[1,3]
10	Process level size=1	4	[]	4	[1,3,4]
11	Add children of 4	4	[]	4	[1,3,4]
12	Queue empty, end	None	[]	None	[1,3,4]

💡 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]	[2,3]	[5,4]	[]	[]
rightmostNode	None	1	3	4	None
rightSideView	[]	[1]	[1,3]	[1,3,4]	[1,3,4]

Key Moments - 3 Insights

Why do we record the last node visited at each level as the rightmost node?

Because we traverse nodes left to right at each level, the last node processed is the rightmost visible node from the right side. See execution_table rows 2, 6, and 10 where the last node is recorded.

Why do we use a queue for traversal instead of recursion?

A queue helps us process nodes level by level (breadth-first), which is necessary to identify the rightmost node at each level. This is shown in the queue state changes in the execution_table.

What happens if the tree is empty?

The function returns an empty list immediately (see execution_sample code line 2), because there are no nodes to view.

Visual Quiz - 3 Questions

Look at the execution_table at Step 6, what is the queue state?

A [2,3]

B [5,4]

C [3]

D []

💡 Hint

Check the 'Queue State' column at Step 6 in the execution_table.

At which step does the rightSideView first include the node '3'?

A Step 8

B Step 4

C Step 6

D Step 10

💡 Hint

Look at the 'Right Side View So Far' column and find when '3' appears.

If the tree had no right child for node 1, how would the rightSideView change?

A [1,2,5]

B [1,2]

C [1,2,4]

D [1,3,4]

💡 Hint

Without right child 3, the rightmost nodes come from left children only, check how queue and rightmost nodes change.

Concept Snapshot

Right Side View of Binary Tree:
- Use level order traversal (queue) to visit nodes level by level.
- At each level, record the last node visited (rightmost node).
- Add children left to right to queue for next level.
- Continue until queue is empty.
- Result is list of rightmost nodes per level.

Full Transcript

To find the right side view of a binary tree, we visit nodes level by level using a queue. At each level, we traverse nodes from left to right and record the last node visited as the rightmost visible node. We add children of each node to the queue to process the next level. This continues until all levels are processed and the queue is empty. The collected nodes form the right side view. If the tree is empty, we return an empty list immediately.