Check if Two Trees are Symmetric in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if both nodes are nil, which means symmetric at this point.

DSA Go

if [1] == nil && q == nil {
    return true
}

Drag options to blanks, or click blank then click option'

Ap

Bq

Croot

Dnode

Attempts:

3 left

💡 Hint

Common Mistakes

Checking only one node for nil instead of both.

Using wrong variable names.

We check if the first node 'p' is nil and the second node 'q' is nil to confirm symmetry at this point.

2fill in blank

medium

Complete the code to check if either node is nil, which means trees are not symmetric.

DSA Go

if p == nil || [1] == nil {
    return false
}

Drag options to blanks, or click blank then click option'

Aq

Broot

Cnode

Dleft

Attempts:

3 left

💡 Hint

Common Mistakes

Checking wrong variable for nil.

Using && instead of || in the condition.

We check if either 'p' or 'q' is nil. If one is nil and the other is not, trees are not symmetric.

3fill in blank

hard

Fix the error in the comparison of node values to check if they are equal.

DSA Go

if p.Val != [1].Val {
    return false
}

Drag options to blanks, or click blank then click option'

Aroot

Bleft

Cnode

Dq

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing with wrong variable.

Using assignment '=' instead of comparison '!='.

We compare the value of node 'p' with node 'q' to check if they are equal for symmetry.

4fill in blank

hard

Fill both blanks to recursively check the left subtree of p with the right subtree of q, and the right subtree of p with the left subtree of q.

DSA Go

return isSymmetricHelper(p.[1], q.[2]) && isSymmetricHelper(p.[3], q.[4])

Drag options to blanks, or click blank then click option'

ALeft

BRight

Cleft

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Using uppercase field names which are incorrect in Go.

Swapping the subtree checks incorrectly.

We check left subtree of p with right subtree of q and right subtree of p with left subtree of q to confirm symmetry.

5fill in blank

hard

Fill both blanks to complete the main function that calls the helper with the root node twice.

DSA Go

func isSymmetric(root *TreeNode) bool {
    if root == nil {
        return true
    }
    return isSymmetricHelper(root[1], root[2])
}

Drag options to blanks, or click blank then click option'

A.Left

B.Right

D.Root

Attempts:

3 left

💡 Hint

Common Mistakes

Passing root.Left or root.Right instead of root.

Adding extra fields that cause errors.

The helper function is called with the root node twice without accessing subfields here.

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