LeetCode OJ：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.

判断两个树是否相同，起是用递归很好解决，但是我一开始居然想使用前序加中序遍历来唯一确定一棵树：

 class Solution {
 public:
     bool isSameTree(TreeNode* p, TreeNode* q) {
         vector<int>res1;
         vector<int>res2;
         if(p == NULL && q == NULL)
             return true;
         else if(p == NULL || q == NULL)
             return false;
         preorderTraversal(p, res1);
         preorderTraversal(q, res2);
         bool ans1 = res1 == res2;
         res1.clear(), res2.clear();
         infixTraversal(p, res1);
         infixTraversal(q, res2);
         bool ans2 = res1 == res2;
         return res1 && res2;

     }
     void preorderTraversal(TreeNode * p, vector<int> & res)
     {
         if(p == NULL) return;
         res.push_back(p->val);
         preorderTraversal(p->left, res);
         preorderTraversal(p->right, res);
     }
     void infixTraversal(TreeNode * p, vector<int> & res)
     {
         if(p == NULL) return;
         infixTraversal(p->left, res);
         res.push_back(p->val);
         infixTraversal(p->right, res);
     }
 };

然而并不可行，只能使用下面这一种方法：

 class Solution {
 public:
     bool isSameTree(TreeNode* p, TreeNode* q) {
         if(!p && !q)
             return true;
         else if(!p && q)
             return false;
         else if(p && !q)
             return false;
         else{
             if(p->val != q->val)
                 return false;
             else
                 return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
         }
     }
 };

当然也可以采用迭代的方式来完成：

 /**
  * Definition for a binary tree node.
  * 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) {
         queue<TreeNode *> pQueue;
         queue<TreeNode *> qQueue;
         pQueue.push(p); //这里只能用队列而不能用栈，因为单向链表的性质决定
         qQueue.push(q);
         while(!pQueue.empty() && !qQueue.empty()){
             TreeNode * pTmp = pQueue.front();
             TreeNode * qTmp = qQueue.front();
             pQueue.pop(), qQueue.pop();
             if(!pTmp && !qTmp)
                 continue;
             else if(pTmp && !qTmp || !pTmp && qTmp || pTmp->val != qTmp->val)
                 return false;
             else{
                 pQueue.push(pTmp->left);
                 pQueue.push(pTmp->right);
                 qQueue.push(qTmp->left);
                 qQueue.push(qTmp->right);
             }
         }
         return pQueue.empty() && qQueue.empty();
     }
 };

下面是java代码：

递归的：

 /**
  * Definition for a binary tree node.
  * public class TreeNode {
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
  *     TreeNode(int x) { val = x; }
  * }
  */
 public class Solution {
     public boolean isSameTree(TreeNode p, TreeNode q) {
         if(p == null && q == null)
             return true;
         else if(p == null)
             return false;
         else if(q == null)
             return false;
         else{
             if(p.val == q.val){
                 return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
             }else
                 return false;
         }
     }
 }

迭代版：

 public class Solution {
     public boolean isSameTree(TreeNode p, TreeNode q) {
         Queue<TreeNode> queueP = new LinkedList<TreeNode>();
         Queue<TreeNode> queueQ = new LinkedList<TreeNode>();
         TreeNode p1, p2;
         queueP.add(p);
         queueQ.add(q);
         while(!queueP.isEmpty() && !queueQ.isEmpty()){
             p1 = queueP.poll();
             p2 = queueQ.poll();
             if(p1 == null && p2 != null ||
                p1 != null && p2 == null)
                return false;
             if(p1 == null && p2 == null)
                 continue;
             if(p1.val == p2.val){
                 queueP.add(p1.left);
                 queueP.add(p1.right);
                 queueQ.add(p2.left);
                 queueQ.add(p2.right);
             }else return false;
         }
         if(queueP.isEmpty() && queueQ.isEmpty())
             return true;
         return false;
     }
 }