Same Tree

Given two binary trees, write a function to check if they are equal or not.

Two binary trees are considered equal if they are structurally identical and the nodes have the same value.

---------------------------------------------

1. 递归，中序便利

2. 栈式深度优先遍历

3. 队列广度优先便利

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode *p, TreeNode *q) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        
        // 1
        if (p == NULL || q == NULL) return p == q;
        if (p->val != q->val) return false;
        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
        
        // 2
        /*
        stack<TreeNode*> pt, qt;
        pt.push(p);
        qt.push(q);
        while (!pt.empty() && !qt.empty()) {
            TreeNode *pnode = pt.top();
            pt.pop();
            TreeNode *qnode = qt.top();
            qt.pop();
            if (pnode == NULL || qnode == NULL) {
                if (pnode != qnode) return false;
                continue;
            }
            
            if (pnode->val != qnode->val) return false;
            pt.push(pnode->left);
            pt.push(pnode->right);
            qt.push(qnode->left);
            qt.push(qnode->right);
        }
        
        return pt.empty() && qt.empty();
        */
        
        // 3
        /*
        queue<TreeNode*> quep, queq;
        quep.push(p);
        queq.push(q);
        while (!quep.empty() && !queq.empty()) {
            TreeNode *pnode = quep.front();
            quep.pop();
            TreeNode *qnode = queq.front();
            queq.pop();
            if (pnode == NULL || qnode == NULL) {
                if (pnode != qnode) return false;
                continue;
            }
            
            if (pnode->val != qnode->val) return false;
            quep.push(pnode->left);
            quep.push(pnode->right);
            queq.push(qnode->left);
            queq.push(qnode->right);
        }
        
        return quep.empty() && queq.empty();
        */
    }
};