Why Right Side View of Binary Tree in DSA Typescript?

The Big Idea

What if you could instantly see only the branches visible from one side of a tree without guessing?

The Scenario

Imagine you are standing on the right side of a tall tree and want to see which branches are visible from your view. If you try to list these branches by looking at the tree from the front or top, you might miss some branches that are hidden behind others.

The Problem

Manually checking each branch from different angles is slow and confusing. You might write down branches multiple times or miss some because you don't have a clear way to know which branch is the rightmost at each level.

The Solution

The "Right Side View of Binary Tree" helps you see only the branches visible from the right side. It goes level by level and picks the last branch you would see, making it easy to list just those branches without confusion or repetition.

Before vs After

✗ Before

function rightSideView(root) {
  // Manually try to check each level and guess rightmost
  // This can be messy and error-prone
}

✓ After

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

What It Enables

This concept lets you quickly find the visible nodes from the right side of any binary tree, helping in visualizing and understanding tree structures clearly.

Real Life Example

In a family tree, if you want to see the last child in each generation from a certain viewpoint, this method helps you list those children easily without confusion.

Key Takeaways

Manual checking of rightmost nodes is confusing and slow.

Right Side View picks the last node at each level efficiently.

It helps visualize trees from a new perspective clearly.

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