LeetCode 之相同的树

问题描述：

给定两个二叉树，编写一个函数来检验它们是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1:

输入:       1         1
          / \       / \
         2   3     2   3

        [1,2,3],   [1,2,3]

输出: true

示例 2:

输入:      1          1
          /           \
         2             2

        [1,2],     [1,null,2]

输出: false

示例 3:

输入:       1         1
          / \       / \
         2   1     1   2

        [1,2,1],   [1,1,2]

输出: false

老规矩 先来自己的，非递归实现，队列层次遍历比较

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
     public boolean isSameTree(TreeNode p, TreeNode q) {
      Queue<TreeNode> queue1 = new ArrayDeque<>();
        Queue<TreeNode> queue2 = new ArrayDeque<>();
        if(p==null||q==null){
            if(p==null&&q==null){
                return true;
            }
            return false;
        }
            queue1.add(p);
            queue2.add(q);
            while (!queue1.isEmpty()) {
                if (queue2.isEmpty()) {
                    return false;
                }
                TreeNode node1 = queue1.remove();
                TreeNode node2 = queue2.remove();
                if (node1.val != node2.val) {
                    return false;
                }
                if (node1.left != null && node2.left!=null) {
                        queue1.add(node1.left);
                        queue2.add(node2.left);
                    }else{
                    if(node1.left==null&&node2.left==null){
                    }else{
                        return false;
                    }
                }
                if (node1.right != null && node2.right!=null) {
                    queue1.add(node1.right);
                    queue2.add(node2.right);
                }else{
                    if(node1.right==null&&node2.right==null){
                    }else{
                        return false;
                    }
                }
                }
        if(!queue2.isEmpty()){
            return false;
        }
        return true;
    }
}

再来一个大神的递归实现，

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

奇怪的是，大神的递归比我写的非递归快，让我难以接受，后来仔细分析，其实有几点原因，自身写的判断条件有些重复累赘，利用队列，队列的操作费时，而且最最最重要的就是算法所传递的例子都是比较“小”的树，如果树比较深，非递归的优势就能展现出来了，不过low 还是  我low。