【剑指offer系列】26-树的子结构（bfs宽度优先遍历、前序遍历）

题目：

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

public class IsSubStructure {
    public static void main(String[] args) {
        TreeNode root1 = new TreeNode(3);
        TreeNode n1 = new TreeNode(6);
        TreeNode n2 = new TreeNode(7);
        TreeNode n3 = new TreeNode(1);
        TreeNode n4 = new TreeNode(8);
        root1.left = n1;
        root1.right = n2;
        n1.left = n3;
        n1.right = n4;

        TreeNode n11 = new TreeNode(6);
        TreeNode n21 = new TreeNode(1);
        n11.left = n21;

        boolean res = isSubStructure(root1, n11);
        System.out.println(res);
    }

    public static boolean isSubStructure(TreeNode r1, TreeNode r2) {
        if (r1 == null || r2 == null) {
            return false;
        }
        // 1.r2的bfs结果
        List<TreeNode> r2BfsList = new ArrayList<>();
        bfs(r2BfsList, r2);

        // 2.r1的前序结果
        List<TreeNode> r1PreList = new ArrayList<>();
        preTraverse(r1PreList, r1);

        // 3. r1的前序结果中，节点的子树，是否有bfs == r2的bfs
        return r1PreList.stream().anyMatch(node -> subTree(node, r2BfsList));
    }

    private static void bfs(List<TreeNode> bfsList, TreeNode root) {
        Queue<TreeNode> queue = new LinkedBlockingQueue<>();
        queue.add(root);
        while (queue.size() > 0) {
            TreeNode node = queue.poll();
            bfsList.add(node);
            if (node.left != null) {
                queue.add(node.left);
            }
            if (node.right != null) {
                queue.add(node.right);
            }
        }
    }

    private static void preTraverse(List<TreeNode> preList, TreeNode root) {
        if (root == null) {
            return;
        }
        preList.add(root);
        preTraverse(preList, root.left);
        preTraverse(preList, root.right);
    }

    private static boolean subTree(TreeNode r1SubNode, List<TreeNode> r2PreList) {
        Queue<TreeNode> queue = new LinkedBlockingQueue<>();
        queue.add(r1SubNode);
        int count = 0;
        int allowCount = r2PreList.size();
        List<TreeNode> r1SubNodeBfsList = new ArrayList<>();
        while (count < allowCount && queue.size() > 0) {
            TreeNode node = queue.poll();
            r1SubNodeBfsList.add(node);
            if (node.left != null) {
                queue.add(node.left);
            }
            if (node.right != null) {
                queue.add(node.right);
            }
            count ++;
        }
        if (r1SubNodeBfsList.size() < r2PreList.size()) {
            return false;
        }
        List<Integer> l1 = r1SubNodeBfsList.stream().map(node -> node.val).collect(Collectors.toList());
        List<Integer> l2 = r2PreList.stream().map(node -> node.val).collect(Collectors.toList());
        return l1.equals(l2);
    }
}