[Leetcode] Binary tree-- 572. Subtree of Another Tree

Posted 2020-09-30 安新

Given two non-empty binary trees s and t, check whether tree t has exactly the same structure and node values with a subtree of s. A subtree of s is a tree consists of a node in s and all of this node\'s descendants. The tree s could also be considered as a subtree of itself.

Example 1:
Given tree s:

     3
    / \\
   4   5
  / \\
 1   2

Given tree t:

   4 
  / \\
 1   2

Return true, because t has the same structure and node values with a subtree of s.

 

Example 2:
Given tree s:

     3
    / \\
   4   5
  / \\
 1   2
    /
   0

Given tree t:

   4
  / \\
 1   2

Return false.

 

Solution:

  1.method use recursive and compare whether it is the same tree for each substree rooted at s\' and the tree t

      it takes o(mn) time ; m is the size of s, n is the size of t

 

 2. use preorder traversal and innorder traversal;  o(m+n)

 

Here I analysis why for both traversal.

 for inorder traversal

  for example 1:  s list [ #, 1, #, 4, #, 2,  #,3,  #, 5, #] ,  t list [#, 1, #, 4, #, 2, #]

      example 2: s list [#, 1,#, 4, #, 0, #, 2, #, 3, 5, #, #], t list [ #, 1, #, 4, #, 2, #]

      example 3:  s list [ #, 4, #, 3, #, 5, #, 1, #, 2, #];       [#, 4, #, 3, #];           it is the sublist of s, but not the subtree of s,  does not work for inorder

      but for the preorder of this, s list [1, 4, #, 3, #, 5, #, #, 2, #, #], t list [4, #,3, #, #] ;       it works.

 

 1         def helperRecursiveInOrder(root, l):
 2             if root is None:
 3                 l.append (str("#"))
 4             else:
 5                 helperRecursiveInOrder(root.left, l)
 6                 l.append(str(root.val))
 7                 helperRecursiveInOrder(root.right, l)
 8         
 9                 
10         def helperRecursivePreOrder(root, l):
11             if root is None:
12                 l.append (str("#"))
13             else:
14                 l.append(str(root.val))
15                 helperRecursivePreOrder(root.left, l)
16                 helperRecursivePreOrder(root.right, l)
17         
18         
19         lsIn = []
20         helperRecursiveInOrder(s, lsIn)
21         ltIn = []
22         helperRecursiveInOrder(t, ltIn)
23         strSIn = ",".join(lsIn)
24         strTIn = ",".join(ltIn)
25         
26         lsPre = []
27         helperRecursivePreOrder(s, lsPre)
28         ltPre = []
29         helperRecursivePreOrder(t, ltPre)
30         strSPre = ",".join(lsPre)
31         strTPre = ",".join(ltPre)
32         #print ("str: ", strSPre, strTPre, lsPre)
33         if(strTIn in strSIn and strTPre in strSPre):                     
34             return True
35         else:
36             return False

 

3. After finishing this, I checked the answer online, actually, it used preorder traversal  only to tackle this problem.

 if we simply process the case like s = [12] , t =[2];     with the \',\' added to each node,

 with the preOrder, it also works.

 Refer to the work from  http://www.cnblogs.com/grandyang/p/6828687.html

 

 1         def helperRecursivePreOrder(root, l):
 2             if root is None:
 3                 l.append (str("#"))
 4             else:
 5                 l.append(\',\' + str(root.val))
 6                 helperRecursivePreOrder(root.left, l)
 7                 helperRecursivePreOrder(root.right, l)
 8         lsPre = []
 9         helperRecursivePreOrder(s, lsPre)
10         ltPre = []
11         helperRecursivePreOrder(t, ltPre)
12         strSPre = ",".join(lsPre)
13         strTPre = ",".join(ltPre)
14         #print ("str: ", strSPre, strTPre, lsPre)
15         if(strTPre in strSPre):                     
16             return True
17         else:
18             return False
19