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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of symmetric check for two identical trees

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

DSA Go

package main

import "fmt"

type TreeNode struct {
    Val   int
    Left  *TreeNode
    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() {
    tree1 := &TreeNode{Val: 1, Left: &TreeNode{Val: 2}, Right: &TreeNode{Val: 3}}
    tree2 := &TreeNode{Val: 1, Left: &TreeNode{Val: 2}, Right: &TreeNode{Val: 3}}
    fmt.Println(isSymmetric(tree1, tree2))
}

A true

B Compilation error

C Runtime panic

D false

💡 Hint

Check if the trees are mirror images, not just identical.

The function checks if two trees are mirror images. The given trees are identical but not mirrors because left and right children do not match in mirrored positions.

❓ Predict Output

intermediate

Output when one tree is nil and the other is not

What does the following Go code print when checking symmetry between a nil tree and a non-nil tree?

DSA Go

package main

import "fmt"

type TreeNode struct {
    Val   int
    Left  *TreeNode
    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() {
    var tree1 *TreeNode = nil
    tree2 := &TreeNode{Val: 1}
    fmt.Println(isSymmetric(tree1, tree2))
}

A Compilation error

B Runtime panic

C false

D true

💡 Hint

One tree is empty, the other is not.

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

🔧 Debug

advanced

Identify the error in symmetric tree check code

What error will the following Go code produce when run?

DSA Go

package main

import "fmt"

type TreeNode struct {
    Val   int
    Left  *TreeNode
    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.Left) && isSymmetric(t1.Right, t2.Right)
}

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

A false

B true

C Compilation error

D Runtime panic

💡 Hint

Check the recursive calls for symmetry logic.

The code compares left with left and right with right, which checks for equality, not mirror symmetry.

🧠 Conceptual

advanced

Understanding mirror symmetry in binary trees

Which statement 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 positions.

B The left subtree of one tree must be a mirror reflection of the right subtree of the other tree, and vice versa.

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

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

💡 Hint

Think about mirror reflection, not just equality.

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

❓ Predict Output

expert

Output of symmetric check on complex trees

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

DSA Go

package main

import "fmt"

type TreeNode struct {
    Val   int
    Left  *TreeNode
    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() {
    tree1 := &TreeNode{
        Val: 1,
        Left: &TreeNode{
            Val: 2,
            Left: &TreeNode{Val: 3},
            Right: &TreeNode{Val: 4},
        },
        Right: &TreeNode{
            Val: 2,
            Left: &TreeNode{Val: 4},
            Right: &TreeNode{Val: 3},
        },
    }
    tree2 := &TreeNode{
        Val: 1,
        Left: &TreeNode{
            Val: 2,
            Left: &TreeNode{Val: 4},
            Right: &TreeNode{Val: 3},
        },
        Right: &TreeNode{
            Val: 2,
            Left: &TreeNode{Val: 3},
            Right: &TreeNode{Val: 4},
        },
    }
    fmt.Println(isSymmetric(tree1, tree2))
}

A true

B false

C Compilation error

D Runtime panic

💡 Hint

Check mirror positions of nodes carefully.

The trees are mirror images of each other with matching node values in mirrored positions.