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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of symmetric check on two trees

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

DSA Typescript

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

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

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

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

A TypeError

B false

C SyntaxError

D true

💡 Hint

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

The function checks if two trees are mirror images. treeA and treeB differ in structure on the right subtree of the root's children, so they are not symmetric.

🧠 Conceptual

intermediate

Understanding symmetry in binary trees

Which of the following best describes when two binary trees are symmetric?

A They have the same number of nodes regardless of structure.

B They have the same values in the same positions.

C One tree is the mirror image of the other, with matching node values.

D They have identical left subtrees but different right subtrees.

💡 Hint

Symmetry means one tree looks like the mirror reflection of the other.

Two trees are symmetric if one is the mirror image of the other, meaning the left subtree of one matches the right subtree of the other and vice versa, with equal node values.

🔧 Debug

advanced

Identify the error in symmetric tree check

What error will this TypeScript code produce when checking if two trees are symmetric?

DSA Typescript

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

A Returns false for symmetric trees due to wrong recursive calls

B SyntaxError due to missing return statement

C No error, returns correct result

D TypeError because of null property access

💡 Hint

Check if the recursive calls compare the correct subtrees for symmetry.

The code compares left subtree with left subtree and right with right, which checks equality but not symmetry (mirror). It will return false for symmetric trees.

❓ Predict Output

advanced

Output of symmetric check with null trees

What is the output of this TypeScript code when both trees are null?

DSA Typescript

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

console.log(isSymmetric(null, null));

A false

B TypeError

C SyntaxError

D true

💡 Hint

Two empty trees are symmetric by definition.

If both trees are null, the function returns true immediately as they are symmetric (empty trees).

🚀 Application

expert

Number of symmetric subtree pairs in two trees

Given two binary trees, how many pairs of subtrees (one from each tree) are symmetric according to the isSymmetric function below? Consider these trees: Tree1: 1 / \ 2 3 / \ 4 5 Tree2: 1 / \ 3 2 / \ 5 4 Use the isSymmetric function: function isSymmetric(t1: TreeNode | null, t2: TreeNode | null): boolean { if (!t1 && !t2) return true; if (!t1 || !t2) return false; return t1.val === t2.val && isSymmetric(t1.left, t2.right) && isSymmetric(t1.right, t2.left); }

A 5

B 4

C 3

D 6

💡 Hint

Count all subtree pairs including the root and leaf nodes that are mirror images.

The symmetric subtree pairs are: - Leaf nodes 4 and 4 - Leaf nodes 5 and 5 - Subtrees rooted at 2 and 2 - Subtrees rooted at 3 and 3 - The whole trees rooted at 1 and 1 Total 5 unique pairs.

Practice

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

easy

A. They are mirror images of each other around their root.

B. They have the same number of nodes.

C. They have the same values in the same order.

D. They are both balanced binary search trees.

Solution

1. Step 1: Understand symmetry in trees

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

2. Step 2: Differentiate from other properties

   Having the same number of nodes or values in order does not guarantee symmetry; symmetry requires mirrored structure and values.

3. Final Answer:

   They are mirror images of each other around their root. -> Option A

4. Quick Check:

   Symmetry means mirror image = A [OK]

Hint: Symmetric trees mirror each other around the root [OK]

Common Mistakes:

• Confusing symmetry with identical trees
• Thinking same node count means symmetry
• Assuming balanced trees are always symmetric

2. Which TypeScript function signature correctly represents a function to check if two trees are symmetric?

easy

A. function symmetricCheck(root1: TreeNode, root2: TreeNode): void

B. function isSymmetric(root1: TreeNode, root2: TreeNode): boolean

C. function checkSymmetry(tree1: TreeNode, tree2: TreeNode): number

D. function isSymmetric(root: TreeNode): boolean

Solution

1. Step 1: Identify correct parameters and return type

   The function should take two tree roots and return a boolean indicating symmetry.

2. Step 2: Check function signature correctness

   function isSymmetric(root1: TreeNode, root2: TreeNode): boolean matches this: two TreeNode parameters and boolean return type.

3. Final Answer:

   function isSymmetric(root1: TreeNode, root2: TreeNode): boolean -> Option B

4. Quick Check:

   Two roots + boolean return = D [OK]

Hint: Symmetry check needs two roots and boolean output [OK]

Common Mistakes:

• Using only one root parameter
• Returning number instead of boolean
• Using void return type

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

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;
  }
}

function isMirror(t1: TreeNode | null, t2: TreeNode | null): boolean {
  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 = new TreeNode(1, new TreeNode(2), new TreeNode(3));
const tree2 = new TreeNode(1, new TreeNode(3), new TreeNode(2));
console.log(isMirror(tree1, tree2));

medium

A. SyntaxError

B. false

C. true

D. RuntimeError

Solution

1. Step 1: Understand the isMirror function logic

   It checks if two trees are mirror images by comparing root values and recursively checking left of one with right of other and vice versa.

2. Step 2: Trace the given trees

   tree1 has root 1, left 2, right 3; tree2 has root 1, left 3, right 2. They are mirrors, so isMirror returns true.

3. Final Answer:

   true -> Option C

4. Quick Check:

   Mirror check returns true for these trees [OK]

Hint: Mirror check compares opposite children recursively [OK]

Common Mistakes:

• Confusing left and right child comparison
• Assuming same structure means mirror
• Ignoring null checks

4. Identify the bug in this TypeScript function meant to check if two trees are symmetric:

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

medium

A. It does not check node values before recursion.

B. It misses the base case when both nodes are null.

C. It returns true when one node is null and the other is not.

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

Solution

1. Step 1: Analyze recursive calls

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

2. Step 2: Identify correct mirror comparison

   For 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 D

4. Quick Check:

   Mirror needs cross child comparison = A [OK]

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

Common Mistakes:

• Comparing same side children instead of opposite
• Forgetting to check node values before recursion
• Missing null base cases

5. Given two binary trees, write a TypeScript function that returns true if they are symmetric around their roots, and false otherwise. Which approach correctly solves this problem?

hard

A. Use a helper function to recursively compare left subtree of one tree with right subtree of the other and vice versa.

B. Traverse both trees in preorder and compare the traversal arrays for equality.

C. Check if both trees have the same height and node count.

D. Compare only the root node values of both trees.

Solution

1. Step 1: Understand symmetry check requirements

   Symmetry means the left subtree of one tree is the mirror of the right subtree of the other.

2. Step 2: Choose correct approach

   Recursively comparing left subtree of one with right subtree of the other ensures mirror symmetry is checked properly.

3. Final Answer:

   Use a helper function to recursively compare left subtree of one tree with right subtree of the other and vice versa. -> Option A

4. Quick Check:

   Mirror recursion approach = B [OK]

Hint: Mirror symmetry needs cross subtree recursive comparison [OK]

Common Mistakes:

• Comparing preorder traversals which miss mirror structure
• Checking only height or node count
• Comparing only root values