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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Symmetric Tree Check Function

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

DSA C#

using System;

class TreeNode {
    public int val;
    public TreeNode left, right;
    public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

class Solution {
    public bool AreSymmetric(TreeNode t1, TreeNode t2) {
        if (t1 == null && t2 == null) return true;
        if (t1 == null || t2 == null) return false;
        if (t1.val != t2.val) return false;
        return AreSymmetric(t1.left, t2.right) && AreSymmetric(t1.right, t2.left);
    }
}

class Program {
    static void Main() {
        TreeNode tree1 = new TreeNode(1, new TreeNode(2), new TreeNode(3));
        TreeNode tree2 = new TreeNode(1, new TreeNode(3), new TreeNode(2));
        Solution sol = new Solution();
        Console.WriteLine(sol.AreSymmetric(tree1, tree2));
    }
}

A True

B False

C Runtime exception

D Compilation error

💡 Hint

Think about how symmetry is checked by comparing left subtree of one tree with right subtree of the other.

The function recursively checks if the left subtree of the first tree is symmetric to the right subtree of the second tree and vice versa. Here, tree1 and tree2 are mirror images, so the output is True.

🧠 Conceptual

intermediate

Understanding Symmetry in Binary Trees

Which of the following best describes the condition for two binary trees to be symmetric?

A Both trees must have the same structure and node values in the same order.

B The sum of all node values in both trees must be equal.

C Both trees must have the same number of nodes regardless of structure or values.

D The left subtree of the first tree must be a mirror reflection of the right subtree of the second tree, and vice versa, with matching node values.

💡 Hint

Symmetry means mirror image, not just identical structure or sums.

Symmetry between two trees means one tree's left subtree is the mirror image of the other's right subtree, and their node values match accordingly.

🔧 Debug

advanced

Identify the Error in Symmetry Check Code

What error will the following C# code produce when checking if two trees are symmetric?

DSA C#

public bool AreSymmetric(TreeNode t1, TreeNode t2) {
    if (t1 == null && t2 == null) return true;
    if (t1 == null || t2 == null) return false;
    if (t1.val != t2.val) return false;
    return AreSymmetric(t1.left, t2.left) && AreSymmetric(t1.right, t2.right);
}

A The code returns false for symmetric trees because it compares left with left and right with right instead of mirror sides.

B The code causes a stack overflow due to infinite recursion.

C The code compiles and runs correctly, returning true for symmetric trees.

D The code throws a NullReferenceException when either tree is empty.

💡 Hint

Check how the recursive calls compare subtrees.

The code incorrectly compares the left subtree of one tree with the left subtree of the other, and right with right, instead of comparing left with right and right with left. This causes it to fail for symmetric trees that are mirror images.

📝 Syntax

advanced

Identify the Syntax Error in Tree Symmetry Code

Which option contains a syntax error in the C# method to check if two trees are symmetric?

DSA C#

public bool AreSymmetric(TreeNode t1, TreeNode t2) {
    if (t1 == null && t2 == null) return true
    if (t1 == null || t2 == null) return false;
    if (t1.val != t2.val) return false;
    return AreSymmetric(t1.left, t2.right) && AreSymmetric(t1.right, t2.left);
}

A Incorrect use of '&&' operator; should use '||' instead.

B Incorrect method return type; should be void instead of bool.

C Missing semicolon after 'return true' statement.

D Missing parentheses in the recursive calls.

💡 Hint

Look carefully at the end of each statement.

In C#, each statement must end with a semicolon. The first return statement is missing a semicolon, causing a syntax error.

🚀 Application

expert

Number of Recursive Calls in Symmetry Check

Given two binary trees each with 3 levels fully filled (7 nodes each), how many total recursive calls will the AreSymmetric method make when checking if they are symmetric?

A 15

B 13

C 7

D 27

💡 Hint

Count calls for each node pair including null children.

Each node pair leads to two recursive calls for its children. For 7 nodes, the total calls including null checks sum to 13.

Practice

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

easy

A. They have the same number of nodes.

B. They have the same root value only.

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 [OK]

Hint: Symmetric trees mirror each other exactly [OK]

Common Mistakes:

• Thinking symmetry means identical trees
• Only comparing root values
• Ignoring structure in comparison

2. Which of the following C# method signatures correctly represents a function to check if two trees are symmetric?

easy

A. public void IsSymmetric(TreeNode root1, TreeNode root2)

B. public int IsSymmetric(TreeNode root1, TreeNode root2)

C. public string IsSymmetric(TreeNode root1, TreeNode root2)

D. public bool IsSymmetric(TreeNode root1, TreeNode root2)

Solution

1. Step 1: Determine return type for symmetry check

   The function should return true or false, so return type must be bool.

2. Step 2: Check method signature correctness

   Method with signature public bool IsSymmetric(TreeNode root1, TreeNode root2) matches expected usage.

3. Final Answer:

   public bool IsSymmetric(TreeNode root1, TreeNode root2) -> Option D

4. Quick Check:

   Return type bool for true/false [OK]

Hint: Symmetry check returns true or false, so use bool [OK]

Common Mistakes:

• Using void return type
• Returning int or string instead of bool
• Incorrect parameter types

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

class TreeNode {
  public int val;
  public TreeNode left, right;
  public TreeNode(int x) { val = x; }
}

bool IsMirror(TreeNode t1, TreeNode t2) {
  if (t1 == null && t2 == null) return true;
  if (t1 == null || t2 == null) return false;
  return (t1.val == t2.val) && IsMirror(t1.left, t2.right) && IsMirror(t1.right, t2.left);
}

TreeNode root1 = new TreeNode(1);
root1.left = new TreeNode(2);
root1.right = new TreeNode(3);

TreeNode root2 = new TreeNode(1);
root2.left = new TreeNode(3);
root2.right = new TreeNode(2);

Console.WriteLine(IsMirror(root1, root2));

medium

A. True

B. False

C. Compilation error

D. Runtime exception

Solution

1. Step 1: Analyze tree structures

   root1 has left=2, right=3; root2 has left=3, right=2, which are mirror images.

2. Step 2: Trace IsMirror function calls

   IsMirror compares root values (1==1), then left of root1 with right of root2 (2==2), and right of root1 with left of root2 (3==3), all true.

3. Final Answer:

   True -> Option A

4. Quick Check:

   Mirror check returns true [OK]

Hint: Mirror check compares opposite children recursively [OK]

Common Mistakes:

• Confusing left and right children
• Assuming identical structure means symmetric
• Ignoring null checks

4. Identify the bug in the following C# method that checks if two trees are symmetric:

bool IsMirror(TreeNode t1, TreeNode t2) {
  if (t1 == null || t2 == null) return true;
  if (t1.val != t2.val) return false;
  return IsMirror(t1.left, t2.right) && IsMirror(t1.right, t2.left);
}

medium

A. The first if condition should return false if one node is null and the other is not.

B. The method should return void instead of bool.

C. The comparison t1.val != t2.val is incorrect and should be reversed.

D. The recursive calls should compare t1.left with t2.left and t1.right with t2.right.

Solution

1. Step 1: Check null node handling

   If one node is null and the other is not, trees are not symmetric, so should return false, not true.

2. Step 2: Verify other conditions

   Value comparison and recursive calls are correct for mirror checking.

3. Final Answer:

   The first if condition should return false if one node is null and the other is not. -> Option A

4. Quick Check:

   Null mismatch means false [OK]

Hint: Return false if only one node is null [OK]

Common Mistakes:

• Returning true when one node is null
• Mixing up recursive child comparisons
• Incorrect return types

5. Given two binary trees, write a method to check if they are symmetric around their center. Which approach below correctly solves this problem efficiently?

hard

A. Use a queue to perform level order traversal and compare nodes at each level from left to right.

B. Use a recursive helper that compares left subtree of first tree with right subtree of second tree and vice versa.

C. Check if both trees have the same number of nodes and same root value only.

D. Traverse both trees in preorder and compare the traversal lists for equality.

Solution

1. Step 1: Understand symmetry check logic

   Symmetry means left subtree of one tree matches right subtree of the other and vice versa.

2. Step 2: Evaluate approaches

   Recursive helper comparing opposite subtrees is efficient and correct. Preorder or level order traversals do not capture mirror structure properly.

3. Final Answer:

   Use a recursive helper that compares left subtree of first tree with right subtree of second tree and vice versa. -> Option B

4. Quick Check:

   Mirror recursion solves symmetry [OK]

Hint: Compare opposite subtrees recursively for symmetry [OK]

Common Mistakes:

• Comparing same side subtrees instead of opposite
• Using traversal equality which misses mirror structure
• Ignoring node values in comparison