代码1——dfs：

1. 都为nil，则为true
2. 一个为nil，false
3. 值不等为false
4. 值相等判断字节的，不能直接返回true

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isSameTree(p *TreeNode, q *TreeNode) bool {
    if p == nil && q == nil {
        return true
    }
    if p == nil || q == nil {
        return false
    }
    if p.Val != q.Val {
        return false
    }
    return isSameTree(p.Left, q.Left) && isSameTree(p.Right, q.Right)
}

代码2——bfs：

1. 用两个队列来维护两个bfs，每次取出第一个进行比较
2. 分别是值比较，字节的是否为nil比较，
3. 不为nil，则将左右节点依次放入队列
4. 因为for循环之前从队列中取值，所以初始化队列

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isSameTree(p *TreeNode, q *TreeNode) bool {
    if p == nil && q == nil {
        return true
    }
    if p == nil || q == nil {
        return false
    }
    pp := []*TreeNode{p}
    qq := []*TreeNode{q}
    for len(pp) > 0 && len(qq) > 0 {
        np, nq := pp[0], qq[0]
        pp, qq = pp[1:], qq[1:]
        if np.Val != nq.Val {
            return false 
        }
        lp, rp := np.Left, np.Right
        lq, rq := nq.Left, nq.Right
        if lp == nil && lq != nil || lq == nil && lp != nil {
            return false
        }
        if rp == nil && rq != nil || rq == nil && rp != nil {
            return false
        }
        if lp != nil {
            pp = append(pp, lp)
        }
        if rp != nil {
            pp = append(pp, rp)
        }
        if lq != nil {
            qq = append(qq, lq)
        }
        if rq != nil {
            qq = append(qq, rq)
        }
    }
    return len(pp) == 0 && len(qq) == 0
}