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 > 0)
            {
                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)