Right Side View of Binary Tree in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Right Side View for a Simple Binary Tree

What is the output of the following JavaScript code that prints the right side view of a binary tree?

DSA Javascript

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

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

const root = new TreeNode(1, new TreeNode(2, null, new TreeNode(5)), new TreeNode(3, null, new TreeNode(4)));
console.log(rightSideView(root));

A [1, 3, 5]

B [1, 3, 4]

C [1, 2, 5]

D [1, 2, 4]

💡 Hint

Remember, the right side view shows the last node at each level when viewed from the right side.

The right side view collects the last node at each level. Level 0 has 1, level 1 has 3, and level 2 has 4 as the rightmost nodes.

🧠 Conceptual

intermediate

Understanding the Right Side View Concept

Which of the following best describes the right side view of a binary tree?

A Nodes at the deepest level of the binary tree only.

B Nodes visible when the tree is viewed from the left side, showing the first node at each level.

C All leaf nodes of the binary tree.

D Nodes visible when the tree is viewed from the right side, showing the last node at each level.

💡 Hint

Think about which nodes you see if you look at the tree from the right side.

The right side view includes the last node at each level when the tree is viewed from the right side.

❓ Predict Output

advanced

Output of Right Side View with Unbalanced Tree

What is the output of the following code that prints the right side view of an unbalanced binary tree?

DSA Javascript

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

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

const root = new TreeNode(10, new TreeNode(5, new TreeNode(3), null), new TreeNode(15, null, new TreeNode(20)));
console.log(rightSideView(root));

A [10, 15, 20]

B [10, 5, 20]

C [10, 15, 3]

D [10, 5, 3]

💡 Hint

Check the last node at each level from left to right in the queue.

Level 0 rightmost is 10, level 1 rightmost is 15, level 2 rightmost is 20.

🔧 Debug

advanced

Identify the Error in Right Side View Implementation

What error will the following code produce when trying to get the right side view of a binary tree?

DSA Javascript

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

A No error, returns correct output

B SyntaxError: Unexpected token

C TypeError: Cannot read property 'left' of undefined

D ReferenceError: queue is not defined

💡 Hint

Look carefully at the for loop condition and how queue.shift() behaves.

The for loop runs one extra time (i <= levelSize), causing queue.shift() to return undefined, then accessing node.left causes a TypeError.

🧠 Conceptual

expert

Time Complexity of Right Side View Algorithm

What is the time complexity of the standard breadth-first search approach to find the right side view of a binary tree with n nodes?

A O(n), because each node is visited once

B O(log n), because it only visits nodes on the right side

C O(n^2), because it processes each level multiple times

D O(1), because it only collects rightmost nodes

💡 Hint

Consider how many times each node is processed in the queue.

The algorithm visits each node exactly once in a breadth-first manner, so the time complexity is O(n).