这道题目与堆成二叉树题目很相似，对称二叉树是每次传入的节点组合是 《左子树的左节点 和 右子树的 右节点》 《左子树的右节点 和 右子树的左节点》， 而这道题就更加简单，传入两棵树的左节点和右节点即可。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(p == nullptr && q == nullptr){
            return true;
        }else if(p == nullptr || q == nullptr){
            return false;
        }else if(p->val != q->val){
            return false;
        }
        bool l_tree = isSameTree(p->left, q->left);
        bool r_tree = isSameTree(p->right, q->right);
        return l_tree && r_tree;
    }
};

尝试使用迭代法来完成这道题目，通过队列每次出队两个元素，并对其进行比较，从而判断两个树是否相等。
尽管代码思路很简单，但在实现时，一开始习惯性的写成了层序遍历那样，在将子节点入队时，判断了子节点不为空才让子节点入队，导致出现误判的情况。这里即使是空节点，也是需要入队进行比较的，因为一个树的这个节点为空，但另一棵树对应的这个节点可不一定。

class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        queue<TreeNode*> que;
        if(p != nullptr && q != nullptr){
            que.push(p);
            que.push(q);
        }else if(p == nullptr && q == nullptr){
            return true;
        }else{
            return false;
        }
        while(!que.empty()){
            TreeNode* node1 = que.front();
            que.pop();
            TreeNode* node2 = que.front();
            que.pop();
            
            if(node1 == nullptr && node2 == nullptr){
                continue;
            }
            if(node1 == nullptr || node2 == nullptr){
                return false;
            }
            if(node1->val != node2->val){
                return false;
            }

            que.push(node1->left);
            que.push(node2->left);
            que.push(node1->right);
            que.push(node2->right);
        }
        return true;
    }
};