leetcode树之二叉树子树

572、另一棵树的子树

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

示例1：

输入：root = [3,4,5,1,2], subRoot = [4,1,2]
输出：true

示例2：

输入：root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]
输出：false

---

思路：

通过递归去判断子树

class Solution:
    def isSubtree(self, root: TreeNode, subRoot: TreeNode) -> bool:
        if not root: return False
        # 如果root和subRoot有一个不存在，或者值不一样，那么说明subRoot肯定不是root的子树
        # 如果满足，递归判断左子树和右子树
        def check(root, subRoot):
            if not root and not subRoot: return True
            if not root or not subRoot: return False
            if root.val != subRoot.val: return False
            return check(root.left, subRoot.left) and check(root.right, subRoot.right)
				# 判断subRoot是否是root的子树，以及递归判断是否是左子树，右子树的子树
        return check(root, subRoot) or self.isSubtree(root.left, subRoot) or self.isSubtree(root.right, subRoot)

617、合并二叉树

给你两棵二叉树： root1 和 root2 。

想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始。

示例1：

输入：root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]
输出：[3,4,5,5,4,null,7]

示例2：

输入：root1 = [1], root2 = [1,2]
输出：[2,2]

---

思路：

递归合并二叉树

class Solution:
    def mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:
      	# 如果没有root1或root2，就直接拼接另一个树即可
        if not root1: return root2
        if not root2: return root1
        # 创建根节点并递归获得左节点和右节点
        root = TreeNode(root1.val + root2.val)
        root.left = self.mergeTrees(root1.left, root2.left)
        root.right = self.mergeTrees(root1.right, root2.right)
        return root

652、寻找重复的子树

给定一棵二叉树 root，返回所有重复的子树。

对于同一类的重复子树，你只需要返回其中任意一棵的根结点即可。

如果两棵树具有相同的结构和相同的结点值，则它们是重复的。

示例1：

输入：root = [1,2,3,4,null,2,4,null,null,4]
输出：[[2,4],[4]]

示例2：

输入：root = [2,1,1]
输出：[[1]]

示例3：

输入：root = [2,2,2,3,null,3,null]
输出：[[2,3],[3]]

---

思路：

相同子树，那么子树有着同样的数据结构，这样通过字符串拼接，空节点用#表示，然后结点值之间用，分隔。进行递归判断子树是否相同。这里可以将路径用字典存储，如果路径出现的次数大于等于2，也就是出现了相同的数据结构，可以当次数等于2的时候，将结点添加到结果集。

class Solution:
    def findDuplicateSubtrees(self, root: Optional[TreeNode]) -> List[Optional[TreeNode]]:
        self.cache = collections.defaultdict(int)
        self.ans = []
        def dfs(root):
          	# 空节点返回#，然后当前路径就是当前节点值 + 左子树路径 + 右子树路径
            if not root: return '#'
            left = dfs(root.left)
            right = dfs(root.right)
            cur_path = f"{root.val},{left},{right}"
            # 进行路径次数统计
            self.cache[cur_path] += 1
            # 当路径次数为2的时候，将结点添加到结果集，返回路径
            if self.cache[cur_path] == 2:
                self.ans.append(root)
            return cur_path
        dfs(root)
        return self.ans

872、叶子相似的树

请考虑一棵二叉树上所有的叶子，这些叶子的值按从左到右的顺序排列形成一个 叶值序列 。

举个例子，如上图所示，给定一棵叶值序列为 (6, 7, 4, 9, 8) 的树。

如果有两棵二叉树的叶值序列是相同，那么我们就认为它们是 叶相似 的。

如果给定的两个根结点分别为 root1 和 root2 的树是叶相似的，则返回 true；否则返回 false 。

示例1：

输入：root1 = [3,5,1,6,2,9,8,null,null,7,4], root2 = [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]
输出：true

示例2：

输入：root1 = [1,2,3], root2 = [1,3,2]
输出：false

---

思路：

class Solution:
    def leafSimilar(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> bool:
        if not root1 and not root2: return True
        if not root1 or not root2: return False
        # 递归获取叶子结点
        def getLeaf(root):
            leafs = []
            def dfs(root):
                if not root: return
                if not root.left and not root.right: leafs.append(root.val)
                dfs(root.left)
                dfs(root.right)
            dfs(root)
            return leafs
        # 判断叶子结点数组是否相等
        return getLeaf(root1) == getLeaf(root2)