Check if Two Trees are Symmetric in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of symmetric tree check function

What is the output of the following JavaScript code that checks if two binary trees are symmetric?

DSA Javascript

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

function isSymmetric(t1, t2) {
  if (!t1 && !t2) return true;
  if (!t1 || !t2) return false;
  if (t1.val !== t2.val) return false;
  return isSymmetric(t1.left, t2.right) && isSymmetric(t1.right, t2.left);
}

const treeA = new TreeNode(1, new TreeNode(2), new TreeNode(3));
const treeB = new TreeNode(1, new TreeNode(3), new TreeNode(2));

console.log(isSymmetric(treeA, treeB));

A true

B false

C TypeError

D SyntaxError

💡 Hint

Check if the left subtree of one tree matches the right subtree of the other and vice versa.

The function checks if two trees are mirror images. Here, treeA's left child (2) does not match treeB's right child (2) in mirrored positions because treeA's left child is 2 and treeB's right child is 2, but treeA's right child is 3 and treeB's left child is 3, so the values do not match in mirrored positions. The function returns false.

❓ Predict Output

intermediate

Output when one tree is null

What is the output of the code below when checking symmetry between a non-empty tree and a null tree?

DSA Javascript

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

function isSymmetric(t1, t2) {
  if (!t1 && !t2) return true;
  if (!t1 || !t2) return false;
  if (t1.val !== t2.val) return false;
  return isSymmetric(t1.left, t2.right) && isSymmetric(t1.right, t2.left);
}

const treeA = new TreeNode(1);
const treeB = null;

console.log(isSymmetric(treeA, treeB));

A false

B true

C ReferenceError

D TypeError

💡 Hint

If one tree is null and the other is not, they cannot be symmetric.

The function returns false because one tree exists and the other is null, so they cannot be symmetric.

🔧 Debug

advanced

Identify the output of a symmetric tree check with nested nodes

What is the output of this code that checks if two trees with nested nodes are symmetric?

DSA Javascript

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

function isSymmetric(t1, t2) {
  if (!t1 && !t2) return true;
  if (!t1 || !t2) return false;
  if (t1.val !== t2.val) return false;
  return isSymmetric(t1.left, t2.right) && isSymmetric(t1.right, t2.left);
}

const treeA = new TreeNode(1, new TreeNode(2, new TreeNode(3), null), new TreeNode(4));
const treeB = new TreeNode(1, new TreeNode(4), new TreeNode(2, null, new TreeNode(3)));

console.log(isSymmetric(treeA, treeB));

A true

B false

C RangeError

D SyntaxError

💡 Hint

Check if the left subtree of one tree matches the right subtree of the other recursively.

The trees are mirror images: treeA's left subtree has 2 with left child 3, and treeB's right subtree has 2 with right child 3. The right subtree of treeA is 4 and matches the left subtree of treeB which is 4. So the function returns true.

🧠 Conceptual

advanced

Understanding the base cases in symmetric tree check

In the function to check if two trees are symmetric, why do we return true when both nodes are null and false when only one is null?

A Because returning false for two null nodes would cause infinite recursion.

B Because null nodes are ignored in symmetry checks.

C Because the function only compares values, not structure.

D Because two null nodes mean both subtrees ended symmetrically, but one null means asymmetry.

💡 Hint

Think about what it means for two subtrees to be mirrors when they are empty or partially empty.

Two null nodes mean both subtrees ended at the same time, so they are symmetric. If only one node is null, the other subtree still has nodes, so they are not symmetric.

🚀 Application

expert

Number of symmetric subtree pairs in two trees

Given two binary trees, how many pairs of nodes (one from each tree) form symmetric subtrees? Consider the code below and determine the output.

DSA Javascript

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

function isSymmetric(t1, t2) {
  if (!t1 && !t2) return true;
  if (!t1 || !t2) return false;
  if (t1.val !== t2.val) return false;
  return isSymmetric(t1.left, t2.right) && isSymmetric(t1.right, t2.left);
}

function countSymmetricPairs(t1, t2) {
  if (!t1 && !t2) return 0;
  if (!t1 || !t2) return 0;
  let count = 0;
  if (isSymmetric(t1, t2)) count = 1;
  return count + countSymmetricPairs(t1.left, t2.right) + countSymmetricPairs(t1.right, t2.left);
}

const treeA = new TreeNode(1, new TreeNode(2, new TreeNode(3), null), new TreeNode(4));
const treeB = new TreeNode(1, new TreeNode(4), new TreeNode(2, null, new TreeNode(3)));

console.log(countSymmetricPairs(treeA, treeB));

A 1

B 2

C 4

D 3

💡 Hint

Count each pair of nodes that form symmetric subtrees including leaf nodes.

The pairs are: (root nodes 1-1), (left subtree 2 and right subtree 2), (right subtree 4 and left subtree 4), (left-left 3 and right-right 3). The leaf node pairs count as symmetric subtrees too. Total is 4.

Practice

1. What does it mean for two binary trees to be symmetric?

easy

A. They have the same root value only.

B. They have the same number of nodes.

C. They are mirror images of each other around their center.

D. They have identical left subtrees only.

Solution

1. Step 1: Understand symmetry in trees

   Two trees are symmetric if one is the mirror reflection of the other around the center.

2. Step 2: Compare structure and node values

   Both structure and node values must match in a mirrored way for symmetry.

3. Final Answer:

   They are mirror images of each other around their center. -> Option C

4. Quick Check:

   Symmetry means mirror image = C [OK]

Hint: Symmetric trees mirror each other exactly [OK]

Common Mistakes:

• Thinking same number of nodes means symmetric
• Only comparing root values
• Ignoring structure differences

2. Which of the following is the correct JavaScript function signature to check if two trees are symmetric?

easy

A. function checkSymmetric(tree) {}

B. function isSymmetric(tree1, tree2) {}

C. function symmetricCheck(tree1, tree2, tree3) {}

D. function isSymmetric(tree1) {}

Solution

1. Step 1: Identify parameters needed

   To check symmetry between two trees, we need two tree inputs.

2. Step 2: Match function signature

   Only the function with two parameters for two trees matches the requirement.

3. Final Answer:

   function isSymmetric(tree1, tree2) {} -> Option B

4. Quick Check:

   Two trees need two parameters = B [OK]

Hint: Two trees need two parameters in function [OK]

Common Mistakes:

• Using only one tree parameter
• Adding unnecessary third parameter
• Wrong function naming

3. What will be the output of the following code snippet?

function isMirror(t1, t2) {
  if (!t1 && !t2) return true;
  if (!t1 || !t2) return false;
  return (t1.val === t2.val) && isMirror(t1.left, t2.right) && isMirror(t1.right, t2.left);
}

const tree1 = { val: 1, left: { val: 2, left: null, right: null }, right: { val: 3, left: null, right: null } };
const tree2 = { val: 1, left: { val: 3, left: null, right: null }, right: { val: 2, left: null, right: null } };

console.log(isMirror(tree1, tree2));

medium

A. TypeError

B. false

C. undefined

D. true

Solution

1. Step 1: Check base cases for null nodes

   Both trees have matching null nodes at corresponding mirror positions, so base cases return true.

2. Step 2: Compare node values and recursive calls

   Root values match (1), left of tree1 (2) matches right of tree2 (2), right of tree1 (3) matches left of tree2 (3). All recursive calls return true.

3. Final Answer:

   true -> Option D

4. Quick Check:

   Mirror check returns true for symmetric trees [OK]

Hint: Mirror check compares opposite children recursively [OK]

Common Mistakes:

• Confusing left and right children in recursion
• Ignoring null node base cases
• Assuming order of children doesn't matter

4. Identify the bug in this code snippet that checks if two trees are symmetric:

function isMirror(t1, t2) {
  if (!t1 && !t2) return true;
  if (!t1 || !t2) return false;
  return (t1.val === t2.val) && isMirror(t1.left, t2.left) && isMirror(t1.right, t2.right);
}

medium

A. It compares left with left and right with right instead of mirror sides.

B. It does not check for null nodes.

C. It uses assignment instead of comparison.

D. It returns true too early without recursion.

Solution

1. Step 1: Analyze recursive calls for symmetry

   The function compares t1.left with t2.left and t1.right with t2.right, which checks for identical trees, not mirror symmetry.

2. Step 2: Correct recursive calls for mirror check

   To check symmetry, t1.left should be compared with t2.right and t1.right with t2.left.

3. Final Answer:

   It compares left with left and right with right instead of mirror sides. -> Option A

4. Quick Check:

   Mirror check swaps sides in recursion = A [OK]

Hint: Mirror check swaps left and right children in recursion [OK]

Common Mistakes:

• Comparing same sides instead of mirror sides
• Missing null checks
• Using assignment (=) instead of equality (===)

5. Given two binary trees, write a function to check if they are symmetric. Which approach correctly solves this problem?

hard

A. Use a queue to iteratively compare nodes from left of one tree and right of the other.

B. Compare only the root nodes of both trees.

C. Check if both trees have the same height only.

D. Traverse both trees in preorder and compare node values in order.

Solution

1. Step 1: Understand iterative symmetry check

   Using a queue, we can compare nodes from the left side of one tree with the right side of the other tree iteratively.

2. Step 2: Why other methods fail

   Preorder traversal compares nodes in the same order, not mirror order. Height check or root-only check ignores structure and values.

3. Final Answer:

   Use a queue to iteratively compare nodes from left of one tree and right of the other. -> Option A

4. Quick Check:

   Iterative mirror check uses queue swapping sides = D [OK]

Hint: Use queue to compare opposite sides iteratively [OK]

Common Mistakes:

• Using preorder traversal without mirroring
• Checking only height or root values
• Ignoring iterative approach benefits