剑指offer-面试题26：树的子结构

题目描述

输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)
B是A的子结构， 即 A中有出现和B相同的结构和节点值。
例如: 给定的树 A:

      3   
     /  \   
    4    5
   /  \    
  1    2

给定的树 B：

     4   
    /  
   1 

返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。
示例 1：
输入：A = [1,2,3], B = [3,1]
输出：false
示例 2：
输入：A = [3,4,5,1,2], B = [4,1]
输出：true
限制：
0 <= 节点个数 <= 10000

方法一（BFS）

1.解题思路

• 首先判断特殊情况，当A或B为空时，直接返回false。
• 然后通过BFS方式遍历树A，如果某个节点与B的根节点相同，则进入isSub函数（用于判断A中是否包含B），如果不相等，则一直遍历。
• isSub函数以B树是否为空来进行遍历，如果遍历对的过程中，A，B有节点不相等或者A没有节点了，则证明这次遍历失败，返回false，如果所有节点都相等，返回true。

2.代码实现

class Solution {
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        if(A==null||B==null) return false;
        Deque<TreeNode> queue=new LinkedList<>();
        queue.offer(A);
        while(!queue.isEmpty()){
            TreeNode node=queue.poll();
            if(node.val==B.val&&isSub(node,B)){
                return true;
            }
            if(node.left!=null){
                queue.offer(node.left);
            }
            if(node.right!=null){
                queue.offer(node.right);
            }
        }
        return false;
    }
    private boolean isSub(TreeNode A, TreeNode B){
        Deque<TreeNode> queueA=new LinkedList<>();
        Deque<TreeNode> queueB=new LinkedList<>();
        queueA.offer(A);
        queueB.offer(B);
        while(!queueB.isEmpty()){
            TreeNode nodeA=queueA.poll();
            TreeNode nodeB=queueB.poll();
            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;
    }
}

3.复杂度分析

假设A树节点个数为m，B树节点个数为n

• 时间复杂度：遍历A树的时间复杂度为O(m)，isSub函数的时间复杂度为O(n)，所以时间复杂度为O(m*n)
• 空间复杂度：最坏情况下，需要存储A，B两棵树的所有节点，所以空间复杂度为O(m+n)

方法二（DFS）

1.解题思路

• 首先通过isSub判断A树中是否有B的子结构，如果遍历的过程中，B先结束，说明A中有部分节点和B完全对的上，返回true，如果A先结束，返回false。推进的过程中，需要当前节点相等，并且左子树相等，右子树也相等。
• 主函数里，先判断特殊情况，同BFS。然后如果A树和B树满足isSub或者A的左子树同B树满足isSub或者A的右子树同B树满足isSub，则返回true。

2.代码实现

class Solution {
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        if(A==null||B==null) return false;
        return isSub(A,B)||isSubStructure(A.left,B)||isSubStructure(A.right,B);
    }
    private boolean isSub(TreeNode A, TreeNode B){
        if(B==null) return true;
        if(A==null) return false;
        return A.val==B.val&&isSub(A.left,B.left)&&isSub(A.right,B.right);
    }
}

3.复杂度分析

假设A树节点个数为m，B树节点个数为n

• 时间复杂度：遍历A树的时间复杂度为O(m)，isSub函数的时间复杂度为O(n)，所以时间复杂度为O(m*n)
• 空间复杂度：最坏情况下，递归栈的深度为A中节点总个数，所以空间复杂度为O(m)

剑指offer全集入口： 请戳这里