Check if Two Trees are Symmetric in DSA Java - Build from Scratch

Check if Two Trees are Symmetric

📖 Scenario: Imagine you have two family trees represented as binary trees. You want to check if these two trees are mirror images of each other, meaning they are symmetric in structure and values.

🎯 Goal: Build a Java program that creates two binary trees, sets up a helper method to check symmetry, and then uses this method to determine if the two trees are symmetric.

📋 What You'll Learn

Create two binary trees with exact node values and structure

Add a helper method to check if two trees are symmetric

Use recursion to compare nodes

Print the result as true or false

💡 Why This Matters

🌍 Real World

Checking if two trees are symmetric is useful in computer graphics, data organization, and validating mirrored data structures.

💼 Career

Understanding tree symmetry helps in software development roles involving data structures, algorithms, and system design.

1

Create Two Binary Trees

Create a class called TreeNode with an integer val and two TreeNode references called left and right. Then create two binary trees called tree1 and tree2 with these exact nodes:

tree1: root value 1, left child 2, right child 3
tree2: root value 1, left child 3, right child 2

DSA Java

// Define TreeNode class
// Create tree1 and tree2 with given structure
// Your code here

Hint

Start by defining the TreeNode class with a constructor. Then create tree1 and tree2 with the exact nodes and connections.

2

Add a Helper Method to Check Symmetry

Add a static method called isSymmetricTrees that takes two TreeNode parameters called node1 and node2. This method will help check if the two trees are symmetric.

DSA Java

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int val) {
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

public class Main {
    public static boolean isSymmetricTrees(TreeNode node1, TreeNode node2) {
        // Your code here
    }

    public static void main(String[] args) {
        TreeNode tree1 = new TreeNode(1);
        tree1.left = new TreeNode(2);
        tree1.right = new TreeNode(3);

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

Hint

Use recursion to compare node1 and node2. Check if both are null, if one is null, or if their values differ. Then check their children in a mirrored way.

3

Use the Helper Method to Check Symmetry

Inside the main method, create a boolean variable called result and set it by calling isSymmetricTrees(tree1, tree2).

DSA Java

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int val) {
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

public class Main {
    public static boolean isSymmetricTrees(TreeNode node1, TreeNode node2) {
        if (node1 == null && node2 == null) {
            return true;
        }
        if (node1 == null || node2 == null) {
            return false;
        }
        if (node1.val != node2.val) {
            return false;
        }
        return isSymmetricTrees(node1.left, node2.right) && isSymmetricTrees(node1.right, node2.left);
    }

    public static void main(String[] args) {
        TreeNode tree1 = new TreeNode(1);
        tree1.left = new TreeNode(2);
        tree1.right = new TreeNode(3);

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

        // Your code here
    }
}

Hint

Call isSymmetricTrees with tree1 and tree2 and store the answer in result.

4

Print the Result

Add a System.out.println statement to print the value of the result variable.

DSA Java

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int val) {
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

public class Main {
    public static boolean isSymmetricTrees(TreeNode node1, TreeNode node2) {
        if (node1 == null && node2 == null) {
            return true;
        }
        if (node1 == null || node2 == null) {
            return false;
        }
        if (node1.val != node2.val) {
            return false;
        }
        return isSymmetricTrees(node1.left, node2.right) && isSymmetricTrees(node1.right, node2.left);
    }

    public static void main(String[] args) {
        TreeNode tree1 = new TreeNode(1);
        tree1.left = new TreeNode(2);
        tree1.right = new TreeNode(3);

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

        boolean result = isSymmetricTrees(tree1, tree2);

        // Your code here
    }
}

Hint

Use System.out.println(result); to show if the trees are symmetric.

Practice

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

easy

A. They have identical left subtrees only.

B. They have the same number of nodes.

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

D. They have the same root value 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 = D [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 Java method signature correctly defines a function to check if two trees are symmetric?

easy

A. public boolean isSymmetric(TreeNode root1, TreeNode root2)

B. boolean isSymmetric(TreeNode root1, TreeNode root2) {}

C. public void isSymmetric(TreeNode root1, TreeNode root2)

D. public boolean isSymmetric(TreeNode root)

Solution

1. Step 1: Identify correct return type and parameters

   The method should return boolean and accept two TreeNode parameters for two trees.

2. Step 2: Check method signature syntax

   Public access, boolean return, and parameter types match in public boolean isSymmetric(TreeNode root1, TreeNode root2).

3. Final Answer:

   public boolean isSymmetric(TreeNode root1, TreeNode root2) -> Option A

4. Quick Check:

   Correct signature returns boolean with two TreeNode inputs [OK]

Hint: Boolean return with two TreeNode inputs is needed [OK]

Common Mistakes:

• Using void return type
• Missing public keyword
• Using only one TreeNode parameter

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

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

System.out.println(isSymmetric(root1, root2));

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

medium

A. Runtime exception

B. false

C. Compilation error

D. true

Solution

1. Step 1: Analyze tree structure and values

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

2. Step 2: Trace recursive calls

   Values match and recursive calls check mirrored children, all return true.

3. Final Answer:

   true -> Option D

4. Quick Check:

   Mirror structure and values = true [OK]

Hint: Check mirrored nodes and values recursively [OK]

Common Mistakes:

• Ignoring mirrored child comparison
• Confusing left and right children
• Assuming same structure means false

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

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

medium

A. It compares left with left and right with right instead of mirrored children.

B. It does not check for null nodes.

C. It returns true when both nodes are null.

D. It uses incorrect return type.

Solution

1. Step 1: Review recursive calls for symmetry

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

2. Step 2: Identify correct mirrored comparison

   It should compare t1.left with t2.right and t1.right with t2.left for symmetry.

3. Final Answer:

   It compares left with left and right with right instead of mirrored children. -> Option A

4. Quick Check:

   Mirror check needs cross child comparison [OK]

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

Common Mistakes:

• Comparing same side children instead of mirrored
• Ignoring null checks
• Wrong return type usage

5. Given two binary trees, write a Java method to check if they are symmetric. Which approach correctly solves this problem? A) Traverse both trees in preorder and compare node values in order. B) Recursively check if left subtree of first tree is mirror of right subtree of second tree and vice versa. C) Compare the height of both trees and return true if equal. D) Check if both trees have the same number of leaf nodes.

hard

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

B. Recursively check if left subtree of first tree is mirror of right subtree of second tree and vice versa.

C. Compare the height of both trees and return true if equal.

D. Check if both trees have the same number of leaf nodes.

Solution

1. Step 1: Understand symmetry check requirements

   Symmetry means one tree is mirror image of the other, so left subtree of one matches right subtree of other.

2. Step 2: Evaluate approaches

   Recursively check if left subtree of first tree is mirror of right subtree of second tree and vice versa. correctly uses recursive mirror checks; others ignore structure or order.

3. Final Answer:

   Recursively check if left subtree of first tree is mirror of right subtree of second tree and vice versa. -> Option B

4. Quick Check:

   Mirror recursive check solves symmetry [OK]

Hint: Mirror recursive check is key to symmetry [OK]

Common Mistakes:

• Using preorder traversal comparison
• Comparing only height or leaf counts
• Ignoring mirrored subtree checks