Mirror a Binary Tree in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Mirroring a Simple Binary Tree

What is the output of the following code after mirroring the binary tree?

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

function mirror(root) {
  if (!root) return null;
  const left = mirror(root.left);
  const right = mirror(root.right);
  root.left = right;
  root.right = left;
  return root;
}

// Tree:
//     1
//    / \
//   2   3
//  /     \
// 4       5

const root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.right.right = new Node(5);

mirror(root);

function printTree(node) {
  if (!node) return "null";
  return `${node.value} -> (${printTree(node.left)}, ${printTree(node.right)})`;
}

console.log(printTree(root));

A 1 -> (3 -> (5 -> (null, null), null), 2 -> (null, 4 -> (null, null)))

B 1 -> (2 -> (4 -> (null, null), null), 3 -> (null, 5 -> (null, null)))

C 1 -> (3 -> (null, 5 -> (null, null)), 2 -> (4 -> (null, null), null))

D 1 -> (2 -> (null, 4 -> (null, null)), 3 -> (5 -> (null, null), null))

💡 Hint

Think about swapping the left and right children at every node.

The mirror function swaps the left and right children recursively. The original left subtree becomes the right subtree and vice versa. The printed output shows the root node value, then its left and right subtrees recursively.

🧠 Conceptual

intermediate

Understanding Mirror Operation on Binary Trees

Which statement best describes what happens when you mirror a binary tree?

A Only the leaf nodes are swapped with their siblings.

B Each node's left and right children are swapped recursively throughout the tree.

C The tree is converted into a linked list by flattening all nodes to the right.

D The values of nodes are reversed in level order without changing the structure.

💡 Hint

Focus on what happens to the children of each node.

Mirroring a binary tree means swapping the left and right children of every node recursively. This changes the structure but keeps the node values intact.

🔧 Debug

advanced

Identify the Error in Mirror Function

What error will the following mirror function cause when run on a binary tree?

DSA Javascript

function mirror(root) {
  if (!root) return;
  mirror(root.left);
  mirror(root.right);
  let temp = root.left;
  root.left = root.right;
  root.right = temp;
}

// Tree setup omitted for brevity

A The function returns undefined and does not update the tree.

B TypeError because root.left or root.right might be undefined.

C No error; function works correctly and mirrors the tree.

D Stack overflow due to infinite recursion.

💡 Hint

Check if the function swaps children after recursive calls.

The function correctly swaps left and right children after recursively mirroring subtrees. It does not return anything but modifies the tree in place, which is valid.

❓ Predict Output

advanced

Output After Mirroring a Larger Tree

What is the output of the following code after mirroring the binary tree?

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

function mirror(root) {
  if (!root) return null;
  const left = mirror(root.left);
  const right = mirror(root.right);
  root.left = right;
  root.right = left;
  return root;
}

// Tree:
//       10
//      /  \
//     5    15
//    / \   / \
//   3   7 12  20

const root = new Node(10);
root.left = new Node(5);
root.right = new Node(15);
root.left.left = new Node(3);
root.left.right = new Node(7);
root.right.left = new Node(12);
root.right.right = new Node(20);

mirror(root);

function printTree(node) {
  if (!node) return "null";
  return `${node.value} -> (${printTree(node.left)}, ${printTree(node.right)})`;
}

console.log(printTree(root));

A 10 -> (15 -> (20 -> (null, null), 12 -> (null, null)), 5 -> (7 -> (null, null), 3 -> (null, null)))

B 10 -> (5 -> (3 -> (null, null), 7 -> (null, null)), 15 -> (12 -> (null, null), 20 -> (null, null)))

C 10 -> (15 -> (12 -> (null, null), 20 -> (null, null)), 5 -> (3 -> (null, null), 7 -> (null, null)))

D 10 -> (5 -> (7 -> (null, null), 3 -> (null, null)), 15 -> (20 -> (null, null), 12 -> (null, null)))

💡 Hint

Remember to swap left and right children at every node.

The mirror function swaps left and right children recursively. The original left subtree rooted at 5 becomes the right subtree, and the right subtree rooted at 15 becomes the left subtree, with their children swapped similarly.

🧠 Conceptual

expert

Effect of Mirroring Twice on a Binary Tree

What is the result of mirroring a binary tree twice in a row?

A The tree's node values are reversed in in-order traversal.

B The tree becomes a linked list skewed to the right.

C The tree becomes completely empty (null).

D The tree returns to its original structure.

💡 Hint

Think about what happens when you swap left and right children twice.

Mirroring swaps left and right children. Doing it twice swaps them back, restoring the original tree structure.