【经典算法】LeetCode 111 二叉树的最小深度(Java/C/Python3/Go实现含注释说明,Easy)

• 标签(题目类型)：树、深度优先搜索(DFS)、广度优先搜索(BFS)

题目描述

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

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

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

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：2
示例  2

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5
 
提示：

树中节点数的范围在 [0, 105] 内
-1000 <= Node.val <= 1000

原题：LeetCode 111

思路及实现

方式一：深度优先搜索(DFS)

思路

对于深度优先搜索，我们可以从根节点开始递归遍历整棵树。对于每个节点，我们检查它是否是叶子节点（即没有左子树或右子树）。如果是叶子节点，我们返回1作为当前路径的深度。否则，我们递归地计算左子树和右子树的最小深度，并返回两者中的较小值加1（加1是因为我们要考虑当前节点）。

需要注意的是，如果当前节点只有一个子树（即左子树或右子树为空），我们不能简单地返回另一个子树的最小深度加1。这是因为在这种情况下，我们需要继续沿着当前子树向下搜索，直到找到叶子节点。

代码实现

Java版本

class TreeNode {
   
   
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) {
   
    val = x; }
}

public class Solution {
   
   
    public int minDepth(TreeNode root) {
   
   
        if (root == null) {
   
   
            return 0;
        }
        if (root.left == null && root.right == null) {
   
   
            // 叶子节点
            return 1;
        }
        int leftDepth = Integer.MAX_VALUE;
        int rightDepth = Integer.MAX_VALUE;
        if (root.left != null) {
   
   
            // 递归计算左子树的最小深度
            leftDepth = minDepth(root.left);
        }
        if (root.right != null) {
   
   
            // 递归计算右子树的最小深度
            rightDepth = minDepth(root.right);
        }
        // 返回左右子树中较小值加1
        return Math.min(leftDepth, rightDepth) + 1;
    }
}

说明：

• 我们首先处理根节点为空的情况，直接返回0。
• 然后检查根节点是否为叶子节点，如果是则返回1。
• 对于非叶子节点，我们初始化左右子树的最小深度为Integer.MAX_VALUE。
• 递归地计算左子树和右子树的最小深度，并更新相应的变量。
• 最后返回左右子树中较小值加1作为当前树的最小深度。

C语言版本

#include <limits.h>

struct TreeNode {
   
   
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

int minDepth(struct TreeNode* root) {
   
   
    if (root == NULL) {
   
   
        return 0;
    }
    if (root->left == NULL && root->right == NULL) {
   
   
        return 1;
    }
    int leftDepth = INT_MAX;
    int rightDepth = INT_MAX;
    if (root->left != NULL) {
   
   
        leftDepth = minDepth(root->left);
    }
    if (root->right != NULL) {
   
   
        rightDepth = minDepth(root->right);
    }
    return (leftDepth < rightDepth) ? (leftDepth + 1) : (rightDepth + 1);
}

说明：

• C语言版本与Java版本类似，但使用了INT_MAX来初始化左右子树的最小深度。
• 注意C语言中结构体指针的使用以及递归调用的语法。

Python3版本

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:
        if not root:
            return 0
        if not root.left and not root.right:
            return 1
        leftDepth = float(