Check if Two Trees are Symmetric in DSA Go

Mental Model

Two trees are symmetric if one is a mirror image of the other, meaning their shapes and node values match when flipped.

Analogy: Imagine holding two identical tree-shaped paper cutouts. If you flip one over and it fits exactly on the other, they are symmetric.

Tree1:       1           Tree2:       1
           /   \                   /   \
          2     3                 3     2
         /       \               /       \
        4         5             5         4

Symmetry means Tree2 is Tree1 flipped left to right.

Dry Run Walkthrough

Input: Tree1: 1->2->4 and 1->3->5, Tree2: 1->3->5 and 1->2->4 (mirror structure)

Goal: Check if Tree2 is the mirror image of Tree1

Step 1: Compare root nodes of both trees (1 and 1)

Tree1 root=1, Tree2 root=1

Why: Roots must match for symmetry

Step 2: Compare left child of Tree1 (2) with right child of Tree2 (2)

Tree1 left=2, Tree2 right=2

Why: Mirror means left of one equals right of other

Step 3: Compare right child of Tree1 (3) with left child of Tree2 (3)

Tree1 right=3, Tree2 left=3

Why: Mirror means right of one equals left of other

Step 4: Compare left child of Tree1's left (4) with right child of Tree2's right (4)

Tree1 left.left=4, Tree2 right.right=4

Why: Mirror symmetry continues down the tree

Step 5: Compare right child of Tree1's right (5) with left child of Tree2's left (5)

Tree1 right.right=5, Tree2 left.left=5

Why: Mirror symmetry continues down the tree

Result:

Trees are symmetric because all corresponding nodes match in mirror positions

Annotated Code

DSA Go

package main

import "fmt"

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

func isSymmetric(t1 *TreeNode, t2 *TreeNode) bool {
    if t1 == nil && t2 == nil {
        return true
    }
    if t1 == nil || t2 == nil {
        return false
    }
    if t1.Val != t2.Val {
        return false
    }
    // Recursively check left of t1 with right of t2 and right of t1 with left of t2
    return isSymmetric(t1.Left, t2.Right) && isSymmetric(t1.Right, t2.Left)
}

func main() {
    // Construct Tree1
    t1 := &TreeNode{Val: 1}
    t1.Left = &TreeNode{Val: 2}
    t1.Right = &TreeNode{Val: 3}
    t1.Left.Left = &TreeNode{Val: 4}
    t1.Right.Right = &TreeNode{Val: 5}

    // Construct Tree2 (mirror of Tree1)
    t2 := &TreeNode{Val: 1}
    t2.Left = &TreeNode{Val: 3}
    t2.Right = &TreeNode{Val: 2}
    t2.Left.Left = &TreeNode{Val: 5}
    t2.Right.Right = &TreeNode{Val: 4}

    if isSymmetric(t1, t2) {
        fmt.Println("Trees are symmetric")
    } else {
        fmt.Println("Trees are not symmetric")
    }
}

if t1 == nil && t2 == nil { return true }

both nodes are empty means symmetry at this branch

if t1 == nil || t2 == nil { return false }

one node empty but other not means asymmetry

if t1.Val != t2.Val { return false }

node values must match for symmetry

return isSymmetric(t1.Left, t2.Right) && isSymmetric(t1.Right, t2.Left)

check mirror children recursively

Output

Trees are symmetric

Complexity Analysis

Time: O(n) because we visit each node once to compare

Space: O(h) due to recursion stack where h is tree height

vs Alternative: Compared to flattening trees to arrays and comparing, this uses less space and is faster by checking structure directly

Edge Cases

Both trees are empty

Returns true because empty trees are symmetric

DSA Go

if t1 == nil && t2 == nil { return true }

One tree is empty, other is not

Returns false because structure differs

DSA Go

if t1 == nil || t2 == nil { return false }

Trees have different values at corresponding nodes

Returns false due to value mismatch

DSA Go

if t1.Val != t2.Val { return false }

When to Use This Pattern

When a problem asks if two trees are mirror images or symmetric, use recursive comparison of opposite children to verify symmetry.

Common Mistakes

Mistake: Comparing left child of one tree with left child of the other instead of opposite sides
Fix: Compare left child of first tree with right child of second tree and vice versa

Summary

Checks if two trees are mirror images of each other by comparing nodes recursively.

Use when you need to verify if one tree is the symmetric reflection of another.

The key insight is to compare left subtree of one tree with right subtree of the other recursively.

Practice

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

easy

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

B. They have the same number of nodes.

C. They have the same root value only.

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 A

4. Quick Check:

   Symmetry means mirror image [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 Go function signature correctly represents a function to check if two trees are symmetric?

easy

A. func isSymmetric(t1 *TreeNode) bool

B. func isSymmetric(t1 TreeNode, t2 TreeNode) int

C. func isSymmetric(t1 *TreeNode, t2 *TreeNode) bool

D. func isSymmetric(t1 *TreeNode, t2 *TreeNode) string

Solution

1. Step 1: Identify correct parameter types

   Function should take pointers to TreeNode structs for both trees to compare.

2. Step 2: Identify correct return type

   Return type should be bool to indicate symmetric (true) or not (false).

3. Final Answer:

   func isSymmetric(t1 *TreeNode, t2 *TreeNode) bool -> Option C

4. Quick Check:

   Pointer params and bool return [OK]

Hint: Use pointers and bool return for tree comparison [OK]

Common Mistakes:

• Using value instead of pointer for trees
• Returning int or string instead of bool
• Missing one tree parameter

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

package main
import "fmt"

type TreeNode struct {
    Val int
    Left, Right *TreeNode
}

func isSymmetric(t1, t2 *TreeNode) bool {
    if t1 == nil && t2 == nil {
        return true
    }
    if t1 == nil || t2 == nil {
        return false
    }
    return t1.Val == t2.Val && isSymmetric(t1.Left, t2.Right) && isSymmetric(t1.Right, t2.Left)
}

func main() {
    root1 := &TreeNode{Val: 1, Left: &TreeNode{Val: 2}, Right: &TreeNode{Val: 2}}
    root2 := &TreeNode{Val: 1, Left: &TreeNode{Val: 2}, Right: &TreeNode{Val: 3}}
    fmt.Println(isSymmetric(root1, root2))
}

medium

A. true

B. false

C. Compilation error

D. Runtime panic

Solution

1. Step 1: Compare root nodes

   Both roots have value 1, so check children.

2. Step 2: Compare left and right subtrees

   Left subtree of root1 has value 2, right subtree of root2 has value 3, which differ.

3. Final Answer:

   false -> Option B

4. Quick Check:

   Different child values mean not symmetric [OK]

Hint: Check mirrored child values for symmetry [OK]

Common Mistakes:

• Assuming same root means symmetric
• Ignoring mismatch in child nodes
• Confusing symmetric with identical

4. Identify the bug in the following Go function that checks if two trees are symmetric:

func isSymmetric(t1, t2 *TreeNode) bool {
    if t1 == nil && t2 == nil {
        return true
    }
    if t1 == nil || t2 == nil {
        return false
    }
    return t1.Val == t2.Val && isSymmetric(t1.Left, t2.Left) && isSymmetric(t1.Right, t2.Right)
}

medium

A. The function does not check root node values.

B. The base case for nil nodes is missing.

C. The function should return int, not bool.

D. The recursive calls compare wrong child nodes for symmetry.

Solution

1. Step 1: Check recursive calls for symmetry

   Symmetry requires comparing left of one tree with right of the other, but code compares left with left and right with right.

2. Step 2: Identify correct recursive calls

   Correct calls should be isSymmetric(t1.Left, t2.Right) and isSymmetric(t1.Right, t2.Left).

3. Final Answer:

   The recursive calls compare wrong child nodes for symmetry. -> Option D

4. Quick Check:

   Mirror children must be compared [OK]

Hint: Compare left with right child for symmetry [OK]

Common Mistakes:

• Comparing left with left and right with right
• Missing nil base cases
• Returning wrong type

5. Given two binary trees, write a Go function to check if they are symmetric. Which approach correctly handles the edge case where one tree is nil and the other is not?

hard

A. Return false immediately if one tree is nil and the other is not.

B. Return true if one tree is nil and the other is not.

C. Ignore nil checks and compare node values only.

D. Return true if both trees have the same number of nodes.

Solution

1. Step 1: Handle nil tree edge cases

   If one tree is nil and the other is not, they cannot be symmetric, so return false immediately.

2. Step 2: Ensure correct base cases in recursion

   Only return true if both trees are nil at the same time, otherwise false.

3. Final Answer:

   Return false immediately if one tree is nil and the other is not. -> Option A

4. Quick Check:

   Nil mismatch means not symmetric [OK]

Hint: Check nil mismatch first to avoid errors [OK]

Common Mistakes:

• Returning true when one tree is nil
• Skipping nil checks causing runtime errors
• Comparing only node counts