二叉树的最小深度——递归法、迭代法

Learner_QUN

于 2023-03-21 11:11:47 发布

阅读量1.1k

点赞数

分类专栏： LeetCode练习文章标签：算法数据结构 leetcode Powered by 金山文档

本文链接：https://blog.csdn.net/Learner_QUN/article/details/129684047

版权

LeetCode练习专栏收录该内容

77 篇文章 0 订阅

订阅专栏

本文介绍了如何解决LeetCode中的111号问题——二叉树的最小深度。通过递归和迭代两种方法，详细解释了解题思路和代码实现，重点在于理解最小深度是从根节点到最近叶子节点的最短路径，并在递归过程中正确处理边界情况。

摘要由CSDN通过智能技术生成

1题目

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

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

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

示例 1：

输入：root = [3,9,20,null,null,15,7]

输出：2

示例 2：

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

输出：5

2链接

题目：111. 二叉树的最小深度 - 力扣（Leetcode）

视频：看起来好像做过，一写就错！ | LeetCode：111.二叉树的最小深度_哔哩哔哩_bilibili

3解题思路

本题前序遍历和后序遍历都可以，前序求的是深度，后序求的是高度。

二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）

二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数后者节点数（取决于高度从0开始还是从1开始）

那么使用后序遍历，其实求的是根节点到叶子节点的最小距离，就是求高度的过程，不过这个最小距离也同样是最小深度。

以下讲解中遍历顺序上依然采用后序遍历（因为要比较递归返回之后的结果，本文我也给出前序遍历的写法）。

本题还有一个误区，在处理节点的过程中，最大深度很容易理解，最小深度就不那么好理解，如图：

这就重新审题了，题目中说的是：最小深度是从根节点到最近叶子节点的最短路径上的节点数量。注意是叶子节点。

什么是叶子节点，左右孩子都为空的节点才是叶子节点！

3.1递归法

递归三部曲：

确定递归函数的参数和返回值

参数为要传入的二叉树根节点，返回的是int类型的深度。

代码如下：

int getDepth(TreeNode* node)

确定终止条件

终止条件也是遇到空节点返回0，表示当前节点的高度为0。

代码如下：

if (node == NULL) return 0;

确定单层递归的逻辑

这块和求最大深度可就不一样了，一些同学可能会写如下代码：

int leftDepth = getDepth(node->left);
int rightDepth = getDepth(node->right);
int result = 1 + min(leftDepth, rightDepth);
return result;

这个代码就犯了此图中的误区：

如果这么求的话，没有左孩子的分支会算为最短深度。

所以，如果左子树为空，右子树不为空，说明最小深度是 1 + 右子树的深度。

反之，右子树为空，左子树不为空，最小深度是 1 + 左子树的深度。最后如果左右子树都不为空，返回左右子树深度最小值 + 1 。

3.2迭代法

层序遍历

需要注意的是，只有当左右孩子都为空的时候，才说明遍历到最低点了。如果其中一个孩子不为空则不是最低点

4代码

4.1递归法——后序遍历

//递归法——后序遍历
class Solution {
public:
    int getDepth(TreeNode* root) {
        // 如果节点为空，深度为0
        if (root == nullptr) {
            return 0;
        }
        // 递归计算左子树的深度和右子树的深度
        int leftDepth = getDepth(root->left);//左
        int rightDepth = getDepth(root->right);//右 //后续为中
        // 如果当前节点左子树为空且右子树不为空，则最小深度为1加右子树的最小深度
        if (root->left == nullptr && root->right != nullptr) {
            return 1 + rightDepth;
        }
        // 如果当前节点右子树为空且左子树不为空，则最小深度为1加左子树的最小深度
        if (root->left != nullptr && root->right == nullptr) {
            return 1 + leftDepth;
        }
        // 否则，取其左右子树最小深度的较小值，并加上1作为当前节点的深度，即可得到整棵树的最小深度
        int result = min(leftDepth, rightDepth) + 1;
        return result;
    }

    int minDepth(TreeNode* root) {
        // 调用getDepth函数来获取root节点的最小深度，并返回计算结果
        return getDepth(root);
    }
};

这段 C++ 代码中定义了一个名为 Solution 的类，其中实现了两个方法：

getDepth 函数，递归计算当前节点的深度。如果该节点左子树为空但右子树不为空，则最小深度为1加右子树的最小深度；如果该节点右子树为空但左子树不为空，则最小深度为1加左子树的最小深度；否则，返回左右子树最小深度的较小值，并加上1作为当前节点的深度，即可得到整棵树的最小深度。

minDepth 函数，调用 getDepth 函数并返回计算结果。

4.2递归法——AI生成

//递归法——后序遍历——from AI
// 时间复杂度：O(n)，其中n是二叉树的节点个数。每个节点最多被访问一次，因此时间复杂度是O(n)。
// 空间复杂度：O(h)，其中h是二叉树的高度。最坏情况下，二叉树呈现链状，空间复杂度是O(n)；平均情况下，空间复杂度是O(logn)。
class Solution {
public:
    int minDepth(TreeNode* root) {
        if (!root) { // 如果根节点为空，返回0
            return 0;
        }
        if (!root->left && !root->right) { // 如果根节点左右子树都为空，返回1
            return 1;
        }
        int left_depth = INT_MAX; // 记录左子树最小深度
        if (root->left) {
            left_depth = minDepth(root->left); // 递归求左子树最小深度
        }
        int right_depth = INT_MAX; // 记录右子树最小深度
        if (root->right) {
            right_depth = minDepth(root->right); // 递归求右子树最小深度
        }
        return min(left_depth, right_depth) + 1; // 返回左右子树最小深度加1的最小值
    }
};

该函数的输入参数为二叉树的根节点 root，返回值为二叉树的最小深度。首先判断根节点是否为空，如果为空，直接返回深度为0；如果根节点的左右子树都为空，说明当前节点为叶子节点，返回深度为1。

然后，定义变量 left_depth 和 right_depth 分别记录左右子树的最小深度。如果当前节点有左子树，递归调用 minDepth 函数计算左子树的最小深度；同样的，如果当前节点有右子树，则递归计算右子树的最小深度。然后，返回左右子树最小深度加1的最小值。

这个递归算法的思路是：每次从根节点开始，递归计算左右子树的最小深度，然后返回左右子树最小深度加1的最小值，即为整棵树的最小深度。

4.3迭代法

//迭代法——层序遍历
class Solution{
public:
    int minDepth(TreeNode* root) {
        // 如果节点为空，返回深度为0
        if (root == nullptr) return 0;
        // 创建一个队列，将根节点加入队列中，初始深度为0
        queue<TreeNode*> que;
        que.push(root);
        int depth = 0;
        // 循环遍历队列中的每个节点，直到队列为空
        while (!que.empty()) {
            // 记录当前队列的大小，该大小等于当前层节点的数目
            int size = que.size();
            // 每次遍历队列中的所有节点时，深度加1
            depth++;
            // 遍历当前层的所有节点，将下一层的节点加入队列中
            for (int i = 0; i < size; i++) {
                // 取出队首节点
                TreeNode* node = que.front();
                que.pop();
                // 将左右子节点加入队列中
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                // 如果该节点同时没有左右子节点，返回当前深度
                if (!node->left && !node->right) return depth;
            }
        }
        // 如果整棵树根节点为0，返回深度为0
        return depth;
    }
};

这段代码定义了一个名为 Solution 的类，其中实现了一个 minDepth 函数，该函数用于计算一棵二叉树的最小深度。

该函数的输入参数为二叉树的根节点 root，返回值为二叉树的最小深度。如果 root 节点为空，直接返回深度为0。否则，创建一个队列 que，将 root 节点加入队列中，并初始化深度为0。

然后，执行一个循环，每次循环遍历队列中的所有节点，直到队列为空。在循环内，首先记录当前队列的大小 size，该大小等于当前层节点的数目；然后，将深度 depth 加1，表示进入了下一层；遍历当前层的所有节点，将每个节点的左右子节点加入队列中；如果该节点同时没有左右子节点，说明已经到达最小深度，返回当前深度。

如果循环结束后仍然没有找到任何叶子节点，则整棵树只有根节点，返回深度为1。