剑指 Offer 26（树2）.树的子结构

剑指 Offer 26（树2）.树的子结构

问题描述：

输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)

B是A的子结构， 即 A中有出现和B相同的结构和节点值。

例如:
给定的树 A:

     3
    / \
   4   5
  / \
 1   2
给定的树 B：

   4 
  /
 1
返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。

示例：

输入：A = [1,2,3], B = [3,1]
输出：false

输入：A = [3,4,5,1,2], B = [4,1]
输出：true

解题思路：思路链接

迭代：总体思路:

1. 先遍历树A，如果遍历到和B节点值相同的节点，进入helper方法判断接下来的节点是否都相同；
2. 节点都相同返回True；不相同返回False，并且继续遍历树A找下一个相同的节点；
3. 如果遍历完了A还没有返回过True，说明B不是A的子结构，返回False；

bfs方法：用于判断从A的子树是否有和B相同的部分

1. 正常BFS步骤，用队列存储树A和B相对应的节点nodeA, nodeB；
2. 因为入队的条件是只要树B节点存在就入队，如果A已经没有了相应节点返回False：if not A；
3. 如果A和B对应节点值不相同也返回False：if nodeA.val != nodeB.val；
4. 如果遍历完了B也没有返回过False，说明B是A的子结构，返回True；

附加解释：

1.offer()和add()的区别
add()和offer()都是向队列中添加一个元素。但是如果想在一个满的队列中加入一个新元素，调用 add() 方法就会抛出一个 unchecked 异常，而调用 offer() 方法会返回 false。可以据此在程序中进行有效的判断！

2.peek()和element()的区别
peek()和element()都将在不移除的情况下返回队头，但是peek()方法在队列为空时返回null，调用element()方法会抛出NoSuchElementException异常。

3.poll()和remove()的区别

poll()和remove()都将移除并且返回对头，但是在poll()在队列为空时返回null，而remove()会抛出NoSuchElementException异常。

使用迭代代码bfs实现：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        if(A == null || B == null){
            return false;
        }
        //构建队列将A中的结点，放入队列中
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(A);
        while(!queue.isEmpty()){
            //弹出A树中的结点，判断与子树B中的结点值是否相同
            TreeNode node = queue.poll();
            if(node.val == B.val){
                //当结点相同，判断左子结点和右子结点是否相同
                if(bfs(node,B)){
                    return true;
                }
            }
            //依次寻找A树中其它结点等于B子树结点，直到叶子结点为止
            if(node.left != null){
                queue.offer(node.left);
            }
            if(node.right != null){
                queue.offer(node.right);
            }
        }
        //如果A树为空，则返回false
        return false;
    }

    private boolean bfs(TreeNode nodeA,TreeNode nodeB){
        //将树的结点值放到队列中
        Queue<TreeNode> queueA = new LinkedList<>();
        Queue<TreeNode> queueB = new LinkedList<>();
        queueA.offer(nodeA);
        queueB.offer(nodeB);

        while(!queueB.isEmpty()){
            //弹出两个队列的结点值
            nodeA = queueA.poll();
            nodeB = queueB.poll();
            //当A树没有子节点，即为叶子结点或者或者结点值不同时，返回false
            if(nodeA == null || nodeA.val != nodeB.val){
                return false;
            }
            //判断之后的节点
            if(nodeB.left != null){
                queueA.offer(nodeA.left);
                queueB.offer(nodeB.left);
            }

            if(nodeB.right != null){
                queueA.offer(nodeA.right);
                queueB.offer(nodeB.right);
            }
        }
        return true;
    }
}

递归总体思路：思路链接

若树 B 是树 A的子结构，则子结构的根节点可能为树 A 的任意一个节点。因此，判断树 BB 是否是树 A 的子结构，需完成以下两步工作：

1. 先序遍历树 A 中的每个节点n_A；（对应函数 isSubStructure(A, B)）
2. 判断树 A 中 以 n_A为根节点的子树 是否包含树 B 。（对应函数 recur(A, B)）

算法流程：

isSub(A, B) 函数：

终止条件：

1. 当节点 B 为空：说明树 B 已匹配完成（越过叶子节点），因此返回true ；
2. 当节点 A 为空：说明已经越过树 A 叶子节点，即匹配失败，返回 false ；
3. 当节点 A 和 B的值不同：说明匹配失败，返回 false ；

返回值：

1. 判断 A 和B 的左子节点是否相等，即 recur(A.left, B.left) ；
2. 判断 A 和 B 的右子节点是否相等，即 recur(A.right, B.right) ；

isSubStructure(A, B) 函数：

特例处理： 当 树 A 为空 或 树 B 为空 时，直接返回 false ；

返回值： 若树 B 是树 A 的子结构，则必满足以下三种情况之一，因此用或 || 连接；

1. 以 节点 A 为根节点的子树 包含树 B ，对应 isSub(A, B)；
2. 树 B 是 树 A 左子树 的子结构，对应 isSubStructure(A.left, B)；
3. 树 B 是 树 A 右子树 的子结构，对应 isSubStructure(A.right, B)；

利用递归代码实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSubStructure(TreeNode A, TreeNode B) {
       if(A == null || B == null){
           return false;
       }
       //先从根节点的判断B是不是Ade子树，再从左右子节点开始判断
       //只要从其中一个中找到B子树都返回True
       return isSub(A,B) || isSubStructure(A.left,B) || isSubStructure(A.right,B);

    }

    boolean isSub(TreeNode A,TreeNode B){
        //如果B为空时，代表B子树中的节点都访问结束，A中都能找到对应节点，返回true
        if(B == null){
            return true;
        }
        //如果B不为空A为空，或者两个结点对应值不同，返回false
        if(A == null || A.val != B.val){
            return false;
        }
        //比较完当前子树根节点，还要判断其左右子节点是否相同
        return isSub(A.left,B.left) && isSub(A.right,B.right);
    }
}