剑指offer——树的子结构

题目描述
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
示例1
输入: {8,8,#,9,#,2,#,5},{8,9,#,2}
返回值: true

难度：本题在牛客-剑指offer中为难题，通过率为24%。

题解思路：
1.基本函数：判断B树是否被A树包含。
2 遍历A树，逐个判断。

心路历程：
1. 本题首先想到的是，基本单元为：判断两棵树是否相同。因此编写函数boolean isEqual(rootA, rootB)判断。
2. 在上述函数的基础上，做修改，判断B树是否被A树包含。
3. 麻烦点在于递归时需要分别判断root1，root2的lchild与rchild是否为空！组合情况很多，但是由于我们判断A包含B树，所以当B递归到null时，说明该递归栈是包含的情况，而当A递归到null时，说明该路径是不包含的情况。

初次通过核心代码：

 public boolean isContains(TreeNode root1, TreeNode root2) {
            boolean ansl = false;
            boolean ansr = false;
            if (root1.val != root2.val) {
                return false;
            }
            if (root2.left == null ) {
                ansl = true;
            }else if (root1.left != null && root2.left != null ){
                ansl = isContains(root1.left, root2.left);
            }else {
                return false;
            }
            if ( root2.right == null ) {
                ansr = true;
            } else if (root1.right != null && root2.right != null) {
                ansr = isContains(root1.right, root2.right);
            } else {
                return false;
            }
            return ansl && ansr;
        }

        public boolean recThrough(TreeNode root1, TreeNode root2) {
            if (root1 == null) {
                return false;
            } else {
                return isContains(root1, root2) || recThrough(root1.left, root2) || recThrough(root1.right, root2);
            }
        }

        public boolean HasSubtree(TreeNode root1, TreeNode root2) {
            if (root1 == null || root2 == null) {
                return false;
            }
            return recThrough(root1, root2);
        }
    }

关于上述代码，isContains中的递归写法还是繁琐了！做以下优化：

1. 每次递归并不用去判断lchild与rchild是否为空，可以直接传入，让下次递归判断！
2. HasSubtree()只起到了判断root2是否为空的作用，由逻辑可知：root2，root1可以为空均会导致false，所以可以与recThrough()合并。
3. 当root1与root2的val相等时才需要进行judge，所以可以再外层先做基本判断。（无所谓的其实。）

优化后代码如下：

 public boolean isContains2(TreeNode root1, TreeNode root2) {
            if (root2 == null) {
                return true;
            }
            if (root1 == null) {
                return false;
            }
            if (root1.val != root2.val) {
                return false;
            }
            return isContains2(root1.left, root2.left) && isContains2(root1.right, root2.right) ;
        }


        public boolean HasSubtree(TreeNode root1, TreeNode root2) {
            // 排除掉root2直接为空的情况。当root1为空时也为终止条件。
            if (root1 == null || root2 == null) {
                return false;
            }
            //当相等，再判断
            if (root1.val == root2.val) {
                if (isContains2(root1, root2)) {
                    return true;
                }
            }
            return HasSubtree(root1.left, root2) || HasSubtree(root1.right, root2);
        }

全部可运行代码

package com.JZOffer;

public class 树的子结构 {

    public static class TreeNode {
        int val = 0;
        TreeNode left = null;
        TreeNode right = null;

        public TreeNode(int val) {
            this.val = val;
        }
    }

    public static class Solution {

        public boolean isContains(TreeNode root1, TreeNode root2) {
            boolean ansl = false;
            boolean ansr = false;
            if (root1.val != root2.val) {
                return false;
            }
            if (root2.left == null) {
                ansl = true;
            } else if (root1.left != null && root2.left != null) {
                ansl = isContains(root1.left, root2.left);
            } else {
                return false;
            }
            if (root2.right == null) {
                ansr = true;
            } else if (root1.right != null && root2.right != null) {
                ansr = isContains(root1.right, root2.right);
            } else {
                return false;
            }
            return ansl && ansr;
        }

        public boolean isContains2(TreeNode root1, TreeNode root2) {
            if (root2 == null) {
                return true;
            }
            if (root1 == null) {
                return false;
            }
            if (root1.val != root2.val) {
                return false;
            }
            return isContains2(root1.left, root2.left) && isContains2(root1.right, root2.right) ;
        }


        public boolean HasSubtree(TreeNode root1, TreeNode root2) {
            // 排除掉root2直接为空的情况。当root1为空时也为终止条件。
            if (root1 == null || root2 == null) {
                return false;
            }
            //当相等，再判断
            if (root1.val == root2.val) {
                if (isContains2(root1, root2)) {
                    return true;
                }
            }
            return HasSubtree(root1.left, root2) || HasSubtree(root1.right, root2);
        }
    }

    public static void main(String[] args) {
    	//测试用例
        TreeNode root1 = new TreeNode(8);
        TreeNode l1 = new TreeNode(8);
        TreeNode r1 = new TreeNode(7);
        TreeNode l1l1 = new TreeNode(9);
        TreeNode l1r1 = new TreeNode(2);

        TreeNode l1r1l = new TreeNode(4);
        TreeNode l1r1r = new TreeNode(7);
        root1.left = l1;
        root1.right = r1;
        l1.left = l1l1;
        l1.right = l1r1;
        l1r1.left = l1r1l;
        l1r1.right = l1r1r;
        TreeNode root2 = new TreeNode(8);
        TreeNode bl1 = new TreeNode(9);
        TreeNode br1 = new TreeNode(2);
        root2.left = bl1;
        root2.right = br1;
        Solution solution = new Solution();
        System.out.println(solution.HasSubtree(root1, root2));
    }
}

}