二叉树相关题目

---

100. 相同的树

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

class S100:
    def func(self, p, q):
        if not p and not q:
            return True
        if not p:
            return False
        if not q:
            return False
        if p.val != q.val:
            return False
        return self.func(p.left, q.left) and self.func(p.right, q.right)

101. 对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

class S101:
    def func(self, root):
        def dfs(left, right):
            if not left and not right:
                return True
            elif not left and right:
                return False
            elif left and not right:
                return False
            elif left.val != right.val:
                return False
            else:
                return dfs(left.left, right.right) and dfs(left.right, right.left)

        return dfs(root.left, root.right)

226. 翻转二叉树

class S:
    def inverTree(self,root):
        if not root:
            return None
        root.left,root.right=root.right,root.left
        self.inverTree(root.left)
        self.inverTree(root.right)
        return root

104. 二叉树的最大深度

class S104:
    def func(self, root):
        def dfs(root, depth):
            if not root:  # 如果没有叶子节点返回深度
                return depth
            else:
                return max(dfs(root.left, depth + 1), dfs(root.right, depth + 1))

        dfs(root, 0)

二叉树的前中后序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

class S:
    def func(self, root):
        res = []

        def dfs(node):
            if node is None:
                return
            res.append(node.val)
            dfs(node.left)
            dfs(node.right)

        dfs(root)
        return res

class S1:
    def func(self, root):
        res = []

        def dfs(node):
            if node is None:
                return
            dfs(node.left)
            res.append(node.val)
            dfs(node.right)

        dfs(root)
        return res

class S2:
    def func(self, root):
        res = []

        def dfs(node):
            if node is None:
                return
            dfs(node.left)
            dfs(node.right)
            res.append(node.val)

        dfs(root)
        return res

98. 验证二叉搜索树

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：
节点的左
子树
只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

class S98:
    def func(self):
        self.vec=[]

    def travesal(self,root):
        if root is None:
            return
        self.travesal(root.left)
        self.vec.append(root.val)
        self.travesal(root.right)

    def isVaild(self,root):
        self.rev=[]
        self.travesal(root)
        for i in range(1,len(self.vec)):
            # 注意要小于等于，搜索树里面不能有相同的元素
            if self.vec[i]<=self.vec[i-1]:
                return False
        return True

112. 路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。
叶子节点 是指没有子节点的节点。

class Solution:
    def hasPathSum(self, root: TreeNode, sum: int) -> bool:
        if not root:
            return False
        if not root.left and not root.right and sum == root.val:
            return True
        return self.hasPathSum(root.left, sum - root.val) or self.hasPathSum(root.right, sum - root.val)

---