第17题——树B是否是树A的子结构

题目：

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

思路：

• 方法一：将树A、B的前序遍历出来得到StringA和StringB，判断StringB是否是StringA的一部分，若是则返回True，否则返回False

• 方法二：递归遍历并判断树A节点的值是否等于树B，若相等，则递归判断左右子树的值是否相等，只要出现不等时就返回False

Python

from PrintTreeLayer import PrintTreeLayer
class HasSubTree:
    def HasSubTree(self, root1, root2):
        def convert(p):
            if p:
                return str(p.val) + convert(p.left) + convert(p.right)
            else:
                return " "
        return convert(root2) in convert(root1) if root2 else False
if __name__ == '__main__':
    test = HasSubTree()
    p = PrintTreeLayer()
    array1 = [8, 9, 2, 1, 3, 4, None]
    array2 = [1,3,2]
    root1 = p.arrayToTree(array1, 0)
    root2 = p.arrayToTree(array2, 0)
    result = test.HasSubTree(root1, root2)
    print(result)

PrintTreeLayer是之前的为二叉树写测试用例的程序

import queue
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class PrintTreeLayer:
    def printTreeLayer(self, root):
        depth = self.getDepth(root)
        que = queue.Queue()
        if root is None:
            return None
        que.put(root)
        count = 0
        currentDepth = 0
        beforeCount = 1
        p = TreeNode(-1)
        while que.qsize() > 0:
            out = que.get()
            count += 1
            if out.val == -1:
                print("null", end=" ")
            else:
                print(out.val, end=" ")
            if out.left:
                que.put(out.left)
            elif currentDepth < depth-1:
                que.put(p)
            if out.right:
                que.put(out.right)
            elif currentDepth < depth-1:
                que.put(p)
            if count == beforeCount:
                beforeCount = que.qsize()
                currentDepth += 1
                count = 0


    def arrayToTree(self, array, index):
        root = None
        if index < len(array):
            value = array[index]
            if value is None:
                return None
            root = TreeNode(value)
            root.left = self.arrayToTree(array, index*2+1)
            root.right = self.arrayToTree(array, index*2+2)
            return root
        return root
    def getDepth(self,root):
        if root is None:
            return 0
        ld = self.getDepth(root.left)
        rd = self.getDepth(root.right)
        return max(ld, rd)+1
if __name__ == '__main__':
    test = PrintTreeLayer()
    array = [3, 9, 20, None, None, 15, 7]
    root = test.arrayToTree(array, 0) #转换成了一棵二叉树
    test.printTreeLayer(root)

Java

package nowcoder;

public class S17_HasSubTree {
    public boolean hasSubTree(TreeNode root1, TreeNode root2){
        boolean flag = false;
        if (root1 != null && root2 != null){
            if (root1.val == root2.val)
                flag = Tree1HasTree2(root1, root2);
            if (!flag)
                flag = Tree1HasTree2(root1.left, root2);
            if (!flag)
                flag = Tree1HasTree2(root1.right, root2);
        }
        return flag;
    }
    public boolean Tree1HasTree2(TreeNode root1, TreeNode root2){
        if (root2 == null)
            return true;
        if (root1 == null)
            return false;
        if (root1.val != root2.val)
            return false;
        return Tree1HasTree2(root1.left, root2.left) && Tree1HasTree2(root1.right,root2.right);
    }
    public static void main(String[] args){
        Integer[] array1 = {8,9,2,1,3,4,null};
        Integer[] array2 = {1,3,2};
        S17_HasSubTree s17 = new S17_HasSubTree();
        PrintTreeLayer p = new PrintTreeLayer();
        TreeNode root1 = p.arrayToTree(array1, 0);
        TreeNode root2 = p.arrayToTree(array2, 0);
        System.out.print(s17.hasSubTree(root1, root2));
    }
}