算法训练 Day15

104.二叉树的最大深度

解法1：递归

# 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 maxDepth(self, root: Optional[TreeNode]) -> int:
        # # method 1
        # if not root:
        #     return 0
        # left_depth = self.maxDepth(root.left)
        # right_depth = self.maxDepth(root.right)
        # return 1 + max(left_depth,right_depth)

        # method 2
        max_depth = 0
        def dfs(root,depth):
            if not root:
                return root
            nonlocal max_depth
            max_depth = max(max_depth,depth)
            dfs(root.left,depth+1)
            dfs(root.right,depth+1)
                    
        dfs(root,1)
        return max_depth

解法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 maxDepth(self, root: Optional[TreeNode]) -> int:
        # method 3
        if not root:
            return root
        
        depth = 0
        queue = [root]
        while queue:
            n = len(queue)
            depth += 1
            for _ in range(n):
                node = queue.pop(0)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return depth

111.二叉树的最小深度

解法1：递归

# 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 minDepth(self, root: Optional[TreeNode]) -> int:
        # method 2
        if not root:
            return 0
        min_depth = inf
        def dfs(root,depth):
            nonlocal min_depth
            if not root.left and not root.right:
                min_depth = min(min_depth,depth)
            if root.left:
                dfs(root.left,depth+1)
            if root.right:
                dfs(root.right,depth+1)
        dfs(root,1)
        return min_depth

解法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 minDepth(self, root: Optional[TreeNode]) -> int:
         # method 1
        if not root:
            return 0
        queue = [root]
        min_depth = 1
        while queue:
            n = len(queue)
            for _ in range(n):
                node = queue.pop(0)
                if not node.left and not node.right:
                    return min_depth
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            min_depth += 1
        return min_depth

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

解法1：递归

# 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:
        # method 2
        return self.dfs(root)
    def dfs(self,root):
        if not root:
            return 0
        leftNum = self.dfs(root.left)
        rightNum = self.dfs(root.right)
        total = leftNum + rightNum + 1
        return total

解法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 countNodes(self, root: Optional[TreeNode]) -> int:
        # method 1
        if not root:
            return 0
        
        count = 0
        queue = [root]
        while queue:
            n = len(queue)
            
            for _ in range(n):
                count += 1
                node = queue.pop()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return count