same tree(判断两颗二叉树是否相等)

Input:     1         1
          / \       / \
         2   3     2   3

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

Output: true

Example 2:

Input:     1         1
          /           \
         2             2

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

Output: false

Example 3:

Input:     1         1
          / \       / \
         2   1     1   2

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

Output: false

判断两个二叉树是否相等。

一：使用递归。

public boolean isSameTree(TreeNode p, TreeNode q) {

        if(p==null&&q==null) return true;
        if(p==null||q==null) return false;

        if(p.val==q.val)
            return isSameTree(p.left,q.left)&&isSameTree(p.right,q.right);
        return false;
    }

二：根据遍历出来的顺序，但是由于遍历右左子树可能有一个为空，会影响结果。

class Solution {
    StringBuilder sb1=new StringBuilder();
        StringBuilder sb2=new StringBuilder();
    public boolean isSameTree(TreeNode p, TreeNode q) {
        /**遍历：出现左右子树只有一个为空时，用null代替存储。所以直接用StringBuilder来存储遍历的结果。

        */
        if(p==null&&q==null) return true;
        if(p==null||q==null) return false;

        bianLi(p,sb1);
        bianLi(q,sb2);
        return sb1.toString().equals(sb2.toString());

    }

    public void bianLi(TreeNode node,StringBuilder sb){
        if(node!=null){
            sb.append(node.val);
            if(node.left!=null&&node.right!=null){
                bianLi(node.left,sb);
                bianLi(node.right,sb);
            }
            if(node.left!=null){
                bianLi(node.left,sb);
                sb.append("null");
            }
            if(node.right!=null){
                sb.append("null");
                bianLi(node.right,sb);
            }
        }

    }
}

但是，其实这里不需要输出遍历 的结果，只需要在遍历过程中对两者进行比较就行。

    public boolean isSameTree(TreeNode p, TreeNode q) {

        if(p==null&&q==null) return true;
        if(p==null||q==null) return false;

        return bianLi2(p,q);
}

 public boolean bianLi2(TreeNode node1,TreeNode node2){
        if(node1==null&&node2==null) return true;
        if(node1!=null&&node2!=null){
            if(node1.val!=node2.val) return false;
            return bianLi2(node1.left,node2.left)&&bianLi2(node1.right,node2.right);
        }
        return false;
    }

三：可以不使用递归，使用深度遍历方法，也不需要输出遍历结果，只需在遍历时判断即可

        if(p==null&&q==null) return true;
        if(p==null||q==null) return false;

        //深度优先遍历

        Stack<TreeNode> s1=new Stack<>();
        Stack<TreeNode> s2=new Stack<>();
        s1.push(p);
        s2.push(q);
        while(!s1.isEmpty()&&!s2.isEmpty()){
            TreeNode node1=s1.pop();
            TreeNode node2=s2.pop();
            if(node1.val!=node2.val) return false;
            if(node1.right!=null) s1.push(node1.right);
            if(node2.right!=null) s2.push(node2.right);
            if(s1.size()!=s2.size()) return false;
            if(node1.left!=null) s1.push(node1.left);
            if(node2.left!=null) s2.push(node2.left);
            if(s1.size()!=s2.size()) return false;
        }
        return s1.size()==s2.size();