一、题目描述

原文链接：100. 相同的树


具体描述：
给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1：

输入：p = [1,2,3], q = [1,2,3]
输出：true

示例 2：

输入：p = [1,2], q = [1,null,2]
输出：false

示例 3：

输入：p = [1,2,1], q = [1,1,2]
输出：false

提示：

• 两棵树上的节点数目都在范围 [0, 100] 内
• -10^4 <= Node.val <= 10^4

二、思路分析

如果跟着我昨天做了对称二叉数的话，这道题简直soeasy！分分中手到擒来！
这道题就是比较二叉数是否相同，两种方法，一种递归，一种迭代，其实有递归就必有迭代！
递归解法三部曲：

• 确定参数和返回，参数就是左右数，返回值就是boolean
• 确定终止条件（左右值不相等返回false，左右子树都为空返回true，左右子树一个为空一个不为空返回false，左右值相同则继续比较）
• 确定单层逻辑（比较左右子树的左边，比较左右子树的右边）

三、AC代码

递归解法：

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

        boolean leftCompare = compare(p.left, q.left);
        boolean rightCompare = compare(p.right, q.right);
        return leftCompare && rightCompare;
    }
}

迭代解法：

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNode right) { * this.val = val; * this.left = left; * this.right = right; * } * } */
class Solution {
    
    public boolean isSameTree(TreeNode p, TreeNode q) {
    
        Deque<TreeNode> deque = new LinkedList<>();
        deque.offerFirst(p);
        deque.offerFirst(q);
        while (deque.isEmpty() == false){
    
            TreeNode left = deque.pollFirst();
            TreeNode right = deque.pollFirst();
            
            if (left == null && right == null) continue;
            if (left == null || right == null || left.val != right.val) return false;

            deque.offerFirst(left.left);
            deque.offerFirst(right.left);
            deque.offerFirst(left.right);
            deque.offerFirst(right.right);
        }
        return true;

    }
}

四、总结

• 递归三部曲：确定参数和返回值;确定终止条件;确定单层的逻辑

五、巩固练习

• 572. 另一棵树的子树（遍历root，然后层层验证是否相同）

递归解法：

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNode right) { * this.val = val; * this.left = left; * this.right = right; * } * } */
class Solution {
    
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
    
        if (root == null && subRoot == null) return true;
        else if (root != null && subRoot == null) return false;
        else if (root == null && subRoot != null) return false;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (queue.isEmpty() == false){
    
            int levelLen = queue.size();
            while(levelLen > 0){
    
                TreeNode tmpNode = queue.poll();
                boolean flag = compare(tmpNode, subRoot);
                if (flag == true) return true;
                if (tmpNode.left != null) queue.offer(tmpNode.left);
                if (tmpNode.right != null) queue.offer(tmpNode.right);
                levelLen--;
            }
        }
        return false;
    }
    public boolean compare(TreeNode left, TreeNode right){
    
        if (left == null && right == null) return true;
        else if (left != null && right == null) return false;
        else if (left == null && right != null) return false;
        else if (left.val != right.val) return false;

        boolean leftCompare = compare(left.left, right.left);
        boolean rightCompare = compare(left.right, right.right);
        return leftCompare && rightCompare;
    }
}

迭代解法

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNode right) { * this.val = val; * this.left = left; * this.right = right; * } * } */
class Solution {
    
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
    
        if (root == null && subRoot == null) return true;
        else if (root != null && subRoot == null) return false;
        else if (root == null && subRoot != null) return false;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (queue.isEmpty() == false){
    
            int levelLen = queue.size();
            while(levelLen > 0){
    
                TreeNode tmpNode = queue.poll();
                boolean flag = compare(tmpNode, subRoot);
                if (flag == true) return true;
                if (tmpNode.left != null) queue.offer(tmpNode.left);
                if (tmpNode.right != null) queue.offer(tmpNode.right);
                levelLen--;
            }
        }
        return false;
    }
    public boolean compare(TreeNode left, TreeNode right){
    
        Deque<TreeNode> deque = new LinkedList<>();
        deque.offerFirst(left);
        deque.offerFirst(right);
        while (deque.isEmpty() == false){
    
            TreeNode subLeftTree = deque.pollFirst();
            TreeNode subRightTree = deque.pollFirst();
            if (subLeftTree == null && subRightTree == null) continue;
            if (subLeftTree == null || subRightTree == null || subLeftTree.val != subRightTree.val) return false;
            deque.offerFirst(subLeftTree.left);
            deque.offerFirst(subRightTree.left);
            deque.offerFirst(subLeftTree.right);
            deque.offerFirst(subRightTree.right);
        }
        return true;
    }
}

感谢大家的阅读，我是Alson_Code，一个喜欢把简单问题复杂化，把复杂问题简单化的程序猿！