力扣（2024.08.10）

1. 222：完全二叉树的节点个数

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        def dfs(node, res):
            if not node:
                return
            res.append(node.val)
            dfs(node.left, res)
            dfs(node.right, res)

        res = []
        dfs(root, res)
        return len(res)

 2. 404：左叶子之和

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        def dfs(node, res, isleft):
            if not node:
                return
            if isleft and not node.left and not node.right:
                res.append(node.val)
            dfs(node.left, res, True)
            dfs(node.right, res, False)

        res = []
        isleft = False
        dfs(root, res, isleft)
        return sum(res)

3. 513：找树左下角的值

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        def dfs(node, level, res):
            if not node:
                return
            if len(res) == level:
                res.append([])
            res[level].append(node.val)
            dfs(node.left, level + 1, res)
            dfs(node.right, level + 1, res)

        res = []
        level = 0
        dfs(root, level, res)
        return res[-1][0]

4. 112：路径总和

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        def dfs(node, path, res):
            if not node:
                path.append('None')
                return
            path.append(node.val)
            if not node.left and not node.right:
                res.append(sum(path))
            dfs(node.left, path, res)
            path.pop()
            dfs(node.right, path, res)
            path.pop()

        res = []
        path = []
        dfs(root, path, res)
        if targetSum in res:
            return True
        return False

 5. 113：路径总和2

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        def dfs(node, path, res):
            if not node:
                path.append("None")
                return
            path.append(node.val)
            if not node.left and not node.right:
                res.append(path.copy())
            dfs(node.left, path, res)
            path.pop()
            dfs(node.right, path, res)
            path.pop()

        res = []
        path = []
        dfs(root, path, res)

        final_res = []
        for i in res:
            if sum(i) == targetSum:
                final_res.append(i)
        return final_res

6. 700：二叉搜索树中的搜索

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        def dfs(node, val, res):
            if not node:
                return
            if node.val == val:
                res.append(node)
                return
            elif node.val > val:
                dfs(node.left, val, res)
            elif node.val < val:
                dfs(node.right, val, res)

        res = []
        dfs(root, val, res)
        return res[0] if res else None