Recursive #

func isSymmetric(root *TreeNode) bool {
    return check(root.Left, root.Right)
}

func check(left *TreeNode, right* TreeNode) bool {
    if left == nil && right == nil {
        return true
    }

    if (left == nil && right != nil) || (left != nil && right == nil) || (left.Val != right.Val) {
        return false
    }

    return check(left.Right, right.Left) && check(left.Left, right.Right)
}

Non-Recursive (using Stack) #

func isSymmetric(root *TreeNode) bool {
    stack := NewStack[*TreeNode]()

    stack.Push(root.Left)
    stack.Push(root.Right)

    for !stack.IsEmpty() {
        right := stack.Pop()
        left := stack.Pop()

        // Structural mismatch
        if (right != nil && left == nil) || (right == nil && left != nil) {
            return false
        }

        if left == nil && right == nil {
            continue
        }

        // Value is not same
        if right.Val != left.Val {
            return false
        }

        stack.Push(left.Right)
        stack.Push(right.Left)
        stack.Push(left.Left)
        stack.Push(right.Right)
    }

    return true
}

type Stack[T any] struct {
    arr []T
}

func NewStack[T any]() *Stack[T] {
    return &Stack[T]{
        arr: []T{},
    }
}

func (s *Stack[T]) Push(v T) {
    s.arr = append(s.arr, v)
}

func (s *Stack[T]) Pop() T {
    v := s.arr[len(s.arr) - 1]
    s.arr = s.arr[:len(s.arr) - 1]
    return v
}

func (s *Stack[T]) IsEmpty() bool {
    return len(s.arr) == 0
}