leetcode 111 二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

首先可以想到使用后序深度优先搜索的方法，对于每一个非叶子节点，我们只需要分别计算其左右子树的最小叶子节点深度。这样就将一个大问题转化为了小问题，可以递归地解决该问题。

时间复杂度O(n)， n为节点个数， 空间复杂度O(logn）取决于栈空间

# 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 dfs(self, root):
        if not root:
            min_depth = 0
            return min_depth
        left_min_depth = self.dfs(root.left)
        right_min_depth = self.dfs(root.right)
        if root.left and root.right:
            return min(left_min_depth, right_min_depth) + 1
        elif root.left:
            return left_min_depth + 1
        elif root.right:
            return right_min_depth + 1
        elif root :
            return 1 
        
    def minDepth(self, root: TreeNode) -> int:
        min_depth = self.dfs(root)
        return min_depth
    

同样，我们可以想到使用广度优先搜索的方法，遍历整棵树。当我们找到一个叶子节点时，直接返回这个叶子节点的深度。广度优先搜索的性质保证了最先搜索到的叶子节点的深度一定最小。
时间复杂度O(n) , 空间复杂度O(n)取决于队列的开销，队列中的元素个数不会超过树的节点数。

# 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: TreeNode) -> int:
        queue=[]
        queue.append(root)
        depth = 0
        while queue and queue[0]:
            depth += 1 
            size = len(queue)
            for _ in range(size):
                cur = queue.pop(0)
                if not cur.left and not cur.right:
                    return depth 
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return depth