Right Side View of Binary Tree in DSA Typescript

Mental Model

We want to see the nodes visible when looking at the tree from the right side, which means the rightmost node at each level.

Analogy: Imagine standing on the right side of a tall building with many floors and windows. You only see the windows on the right edge of each floor, not the ones behind or to the left.

      1
     / \
    2   3
     \   \
      5   4

Right side view: 1 -> 3 -> 4

Dry Run Walkthrough

Input: Binary tree: root=1, left=2, right=3, 2's right=5, 3's right=4

Goal: Find the list of nodes visible from the right side: one node per level, the rightmost one

Step 1: Start at root (level 0), add 1 to result

Level 0: [1]
Result: [1]

Why: Root is always visible from the right side

Step 2: Move to level 1, nodes are 2 and 3; pick rightmost 3

Level 1: [2, 3]
Result: [1, 3]

Why: At each level, only the rightmost node is visible

Step 3: Move to level 2, nodes are 5 (from 2) and 4 (from 3); pick rightmost 4

Level 2: [5, 4]
Result: [1, 3, 4]

Why: Rightmost node at level 2 is 4, so it is visible

Step 4: No more levels, end traversal

Traversal complete
Result: [1, 3, 4]

Why: All levels processed, final right side view collected

Result:

Right side view nodes: [1, 3, 4]

Annotated Code

DSA Typescript

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val === undefined ? 0 : val;
    this.left = left === undefined ? null : left;
    this.right = right === undefined ? null : right;
  }
}

function rightSideView(root: TreeNode | null): number[] {
  if (!root) return [];
  const result: number[] = [];
  const queue: (TreeNode | null)[] = [root];

  while (queue.length > 0) {
    const levelSize = queue.length;
    for (let i = 0; i < levelSize; i++) {
      const node = queue.shift()!;
      // Add children for next level
      if (node.left) queue.push(node.left);
      if (node.right) queue.push(node.right);
      // If last node in this level, add to result
      if (i === levelSize - 1) {
        result.push(node.val);
      }
    }
  }
  return result;
}

// Driver code using dry_run input
const root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.right = new TreeNode(5);
root.right.right = new TreeNode(4);

const view = rightSideView(root);
console.log(view.join(", ") + "\n");

if (!root) return [];

handle empty tree edge case

const queue: (TreeNode | null)[] = [root];

initialize queue with root for level order traversal

const levelSize = queue.length;

determine number of nodes at current level

const node = queue.shift()!;

remove node from front of queue to process

if (node.left) queue.push(node.left);

enqueue left child for next level

if (node.right) queue.push(node.right);

enqueue right child for next level

if (i === levelSize - 1) { result.push(node.val); }

add rightmost node of current level to result

Output

1, 3, 4

Complexity Analysis

Time: O(n) because we visit each node exactly once during level order traversal

Space: O(n) because the queue can hold up to all nodes at the widest level

vs Alternative: Compared to DFS with tracking depth, BFS is straightforward and naturally processes nodes level by level, making it easier to pick rightmost nodes

Edge Cases

Empty tree (root is null)

Returns empty list immediately

DSA Typescript

if (!root) return [];

Tree with only one node

Returns list with that single node value

DSA Typescript

const queue: (TreeNode | null)[] = [root];

Tree where some nodes have only left children

Still returns rightmost nodes per level, which may be left children if no right child exists

DSA Typescript

if (node.left) queue.push(node.left);

When to Use This Pattern

When asked to find nodes visible from one side of a tree, use level order traversal and pick the last node at each level to get the right side view.

Common Mistakes

Mistake: Adding the first node of each level instead of the last node
Fix: Add the node only when processing the last node in the current level (i === levelSize - 1)

Mistake: Using preorder or inorder traversal which does not process nodes level by level
Fix: Use BFS (level order traversal) to process nodes level by level

Summary

Finds the rightmost node at each level of a binary tree to show the right side view.

Use when you need to see which nodes are visible from the right side of a tree.

The key insight is to traverse level by level and pick the last node at each level.

Practice

1. What does the "Right Side View of Binary Tree" represent?

easy

A. All nodes at the deepest level of the tree

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

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

D. All leaf nodes of the binary tree

Solution

1. Step 1: Understand the view perspective

   The right side view shows nodes visible when looking at the tree from the right side.

2. Step 2: Identify visible nodes

   Only the rightmost node at each level is visible from the right side.

3. Final Answer:

   Nodes visible when the tree is viewed from the right side -> Option C

4. Quick Check:

   Right side view = rightmost nodes [OK]

Hint: Right side view shows rightmost nodes at each level [OK]

Common Mistakes:

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

2. Which TypeScript syntax correctly defines a binary tree node class for this problem?

easy

A. type TreeNode = { val: number; left?: TreeNode; right?: TreeNode }

B. function TreeNode(val) { this.val = val; this.left = null; this.right = null; }

C. interface TreeNode { val: number; left: TreeNode; right: TreeNode; }

D. class TreeNode { val: number; left: TreeNode | null; right: TreeNode | null; constructor(val: number) { this.val = val; this.left = null; this.right = null; } }

Solution

1. Step 1: Check class definition syntax

   class TreeNode { val: number; left: TreeNode | null; right: TreeNode | null; constructor(val: number) { this.val = val; this.left = null; this.right = null; } } uses TypeScript class with proper types and constructor.

2. Step 2: Compare other options

   function TreeNode(val) { this.val = val; this.left = null; this.right = null; } is JavaScript function, not TypeScript class. interface TreeNode { val: number; left: TreeNode; right: TreeNode; } misses nullability. type TreeNode = { val: number; left?: TreeNode; right?: TreeNode } uses type but lacks constructor.

3. Final Answer:

   class TreeNode with constructor and nullable children -> Option D

4. Quick Check:

   TypeScript class with constructor = class TreeNode { val: number; left: TreeNode | null; right: TreeNode | null; constructor(val: number) { this.val = val; this.left = null; this.right = null; } } [OK]

Hint: Use class with constructor and nullable children for nodes [OK]

Common Mistakes:

• Using JavaScript function instead of TypeScript class
• Not allowing null for left/right children
• Using interface without constructor

3. Given the binary tree below, what is the right side view output?

    1
   / \
  2   3
   \   \
    5   4

function rightSideView(root: TreeNode | null): number[] { const result: number[] = []; if (!root) return result; const queue: (TreeNode | null)[] = [root]; while (queue.length) { const 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; }

medium

A. [1, 3, 4]

B. [1, 2, 5]

C. [1, 3, 5]

D. [1, 2, 4]

Solution

1. Step 1: Traverse level by level

   Level 1: node 1; Level 2: nodes 2, 3; Level 3: nodes 5, 4.

2. Step 2: Pick rightmost node at each level

   Level 1 rightmost: 1; Level 2 rightmost: 3; Level 3 rightmost: 4.

3. Final Answer:

   [1, 3, 4] -> Option A

4. Quick Check:

   Rightmost nodes per level = [1, 3, 4] [OK]

Hint: Pick last node at each level during BFS [OK]

Common Mistakes:

• Choosing leftmost nodes instead of rightmost
• Mixing node values from different levels
• Ignoring null children in traversal

4. Identify the bug in this TypeScript code for right side view and select the fix.

function rightSideView(root: TreeNode | null): number[] {
  const result: number[] = [];
  if (!root) return result;
  const queue: TreeNode[] = [root];
  while (queue.length) {
    const 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;
}

medium

A. Initialize queue as empty array instead of [root]

B. Change queue type to (TreeNode | undefined)[] and check node is not undefined after shift

C. Remove the if condition checking i === size - 1

D. Push left child after right child in the queue

Solution

1. Step 1: Analyze queue.shift() return type

   queue.shift() can return undefined if queue is empty, but here size ensures it's not empty. Still, TypeScript requires checking.

2. Step 2: Fix type safety

   Change queue type to allow undefined and check node is not undefined before accessing properties.

3. Final Answer:

   Change queue type and check node after shift -> Option B

4. Quick Check:

   Type safety requires checking shift result [OK]

Hint: Check shift() result for undefined before use [OK]

Common Mistakes:

• Ignoring possible undefined from shift()
• Removing correct condition for rightmost node
• Changing queue initialization incorrectly

5. You want to find the right side view of a binary tree but only have access to a preorder traversal array with nulls for missing nodes, e.g., [1, 2, null, 5, null, null, 3, null, 4]. How can you adapt your approach to get the right side view?

hard

A. Rebuild the tree from preorder with nulls, then perform BFS right side view

B. Directly pick every second element from the preorder array

C. Use preorder array as is and treat it as right side view

D. Reverse the preorder array and pick first elements

Solution

1. Step 1: Understand preorder with nulls

   The array represents tree nodes with nulls marking missing children, so tree structure is implicit.

2. Step 2: Rebuild tree then apply right side view

   Reconstruct the binary tree from this array, then run BFS to get right side view nodes.

3. Final Answer:

   Rebuild tree from preorder with nulls, then BFS -> Option A

4. Quick Check:

   Need tree structure to find right side view [OK]

Hint: Rebuild tree from traversal before right side view [OK]

Common Mistakes:

• Assuming preorder array directly gives right side view
• Ignoring nulls and tree structure
• Trying to pick nodes without tree reconstruction