leetcode572

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    private string generatepreorderString(TreeNode s)
        {
            StringBuilder sb = new StringBuilder();
            Stack<TreeNode> stacktree = new Stack<TreeNode>();
            stacktree.Push(s);
            while (stacktree.Count > )
            {
                TreeNode popelem = stacktree.Pop();
                if (popelem == null)
                {
                    sb.Append(",#"); // Appending # inorder to handle same values but not subtree cases
                }
                else
                {
                    sb.Append("," + popelem.val);
                }
                if (popelem != null)
                {
                    stacktree.Push(popelem.right);
                    stacktree.Push(popelem.left);
                }
            }
            return sb.ToString();
        }

        public bool IsSubtree(TreeNode s, TreeNode t)
        {
            string spreorder = generatepreorderString(s);
            string tpreorder = generatepreorderString(t);

            return spreorder.Contains(tpreorder);
        }
}

https://leetcode.com/problems/subtree-of-another-tree/#/description

补充一个使用python的实现，思路就是使用二叉树的先序遍历，将节点和空节点存储到字符串中，然后比较t是否是s的字串。

 class Solution:
     s_pre = ""
     t_pre = ""
     def preOrder(self,root):
         if root!=None:
             self.s_pre += '<'+ str(root.val) + '>'
             self.preOrder(root.left)
             self.preOrder(root.right)
         else:
             self.s_pre += '<x>'

     def preOrder2(self,root):
         if root!=None:
             self.t_pre += '<' + str(root.val) + '>'
             self.preOrder2(root.left)
             self.preOrder2(root.right)
         else:
             self.t_pre += '<x>'

     def isSubtree(self, s: 'TreeNode', t: 'TreeNode') -> 'bool':
         self.preOrder(s)
         self.preOrder2(t)
         return self.t_pre in self.s_pre

执行效率还是比较高的。

再补充一个双层递归的实现，我是不喜欢这种方式的，而且执行效率也低。

 class Solution:
     def isSubtree(self, s: TreeNode, t: TreeNode) -> bool:
         if s == None:
             return False
         return self.isSubTreeWithRoot(s,t) or self.isSubtree(s.left,t) or self.isSubtree(s.right,t)

     def isSubTreeWithRoot(self,s,t):
         if s == None and t == None:
             return True
         if s == None or t == None:
             return False
         if s.val != t.val:
             return False
         return self.isSubTreeWithRoot(s.left,t.left) and self.isSubTreeWithRoot(s.right,t.right)