Right Side View of Binary Tree in DSA Typescript - Build from Scratch

Right Side View of Binary Tree

📖 Scenario: You are working with a binary tree, which is like a family tree but each person has at most two children: a left child and a right child. You want to see the tree from the right side, so you only see the rightmost nodes at each level.

🎯 Goal: Build a program that finds the right side view of a binary tree. This means you will list the values of the nodes that are visible when looking at the tree from the right side, level by level.

📋 What You'll Learn

Create a binary tree using a TreeNode class with val, left, and right properties

Create a variable called root that represents the root of the binary tree with exact values

Create a variable called rightSideView to store the visible nodes from the right side

Use a breadth-first search (BFS) approach with a queue to traverse the tree level by level

At each level, add the value of the rightmost node to rightSideView

Print the rightSideView array at the end

💡 Why This Matters

🌍 Real World

Right side view of a binary tree helps in visualizing hierarchical data from a specific angle, useful in UI trees, organizational charts, and decision trees.

💼 Career

Understanding tree traversal and views is important for software engineers working with data structures, algorithms, and system design.

1

Create the Binary Tree Structure

Create a class called TreeNode with a constructor that takes a number val and optional left and right nodes. Then create a variable called root that builds this exact tree:

1
/ \
2 3
\ \
5 4

DSA Typescript

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

// Your code here

Hint

Think of each node as a person with a value and two children. Use the constructor to connect them exactly as shown.

2

Set Up the Result Array

Create a variable called rightSideView and set it to an empty array of numbers. This will hold the values of the nodes visible from the right side.

DSA Typescript

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

const root = new TreeNode(1,
  new TreeNode(2, null, new TreeNode(5)),
  new TreeNode(3, null, new TreeNode(4))
);

// Your code here

Hint

This array will collect the rightmost node values from each level.

3

Traverse the Tree Level by Level

Create a queue array called queue and add root to it. Use a while loop that runs while queue.length > 0. Inside the loop, get the number of nodes at the current level with levelLength = queue.length. Then use a for loop with variable i from 0 to levelLength - 1. Remove the first node from queue and call it node. If node.left exists, add it to queue. If node.right exists, add it to queue. If i === levelLength - 1, add node.val to rightSideView.

DSA Typescript

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

const root = new TreeNode(1,
  new TreeNode(2, null, new TreeNode(5)),
  new TreeNode(3, null, new TreeNode(4))
);

const rightSideView: number[] = [];

// Your code here

Hint

Use a queue to visit nodes level by level. Add children to the queue. The last node at each level is the rightmost one.

4

Print the Right Side View

Write a console.log statement to print the rightSideView array.

DSA Typescript

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

const root = new TreeNode(1,
  new TreeNode(2, null, new TreeNode(5)),
  new TreeNode(3, null, new TreeNode(4))
);

const rightSideView: number[] = [];

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

while (queue.length > 0) {
  const levelLength = queue.length;
  for (let i = 0; i < levelLength; i++) {
    const node = queue.shift()!;
    if (node.left) queue.push(node.left);
    if (node.right) queue.push(node.right);
    if (i === levelLength - 1) {
      rightSideView.push(node.val);
    }
  }
}

// Your code here

Hint

Print the array that holds the right side view values.

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