111. 二叉树的最小深度

题目来源：力扣（LeetCode）https://leetcode-cn.com/problems/minimum-depth-of-binary-tree

题目

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

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

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

示例:

给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回它的最小深度 2.

解题思路

思路： DFS、BFS

审题，题目要求给定二叉树的最小深度。

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

叶子节点： 指的是没有左右子节点的节点。

那么我们这里考虑从根节点出发，使用 DFS、BFS 的思路进行搜索。

DFS

先看使用 DFS（深度优先搜索）的方法，具体做法如下：

• 根节点为空，返回 0；
• 如果根节点不为空，需要判断左右子节点：
  • 左右子节点都为空，那么返回 1；
  • 左右子节点其中一个为空，那么返回不为空子节点的最小深度；
  • 左右子节点均不为空，返回其中较小深度的值。

具体的代码见【代码实现 # DFS】

BFS

这里，也可以使用 BFS（广度优先搜索）的方法，我们使用 BFS 方法时，是逐层去搜索的，那么我们只要发现某一层中，某个节点不存在子节点时，那么也就意味着从根节点到当前节点是最短路径。

具体的代码见【代码实现 # BFS】

代码实现

# DFS
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        # 根节点为空
        if not root:
            return 0
        # 根节点不为空，分别讨论左右子节点
        depth = 1

        # 根节点不为空，但不存在左右子节点，返回 1
        if not root.left and not root.right:
            return 1
        # 不存在右子节点，返回不为空的左子节点最小深度
        elif not root.right:
            depth += self.minDepth(root.left)
        # 返回不为空的右子节点最小深度
        elif not root.left:
            depth += self.minDepth(root.right)
        # 左右子节点均不为空，返回较小深度
        else:
            left_depth = self.minDepth(root.left)
            right_depth = self.minDepth(root.right)
            depth += min(left_depth, right_depth)

        return depth

# BFS
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0

        from collections import deque
        queue = deque()
        queue.append(root)

        depth = 1

        while queue:
            # 逐层搜索，先记录每层节点数
            size = len(queue)
            for _ in range(size):
                node = queue.popleft()
                # 当前节点不存在子节点，那么当前节点在最小路径上
                if not node.left and not node.right:
                    return depth
                # 其中一个节点为空，返回不为空节点的最小深度
                elif not node.right:
                    queue.append(node.left)
                elif not node.left:
                    queue.append(node.right)
                # 左右子节点都不会空，返回其中较小深度
                else:
                    queue.append(node.left)
                    queue.append(node.right)
                
            depth += 1

实现结果