二叉树的深度

二叉树的深度

二叉树的最小深度

题目描述

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

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

**说明：**叶子节点是指没有子节点的节点。LeetCode链接

分析

• 首先对于树的问题，我们一般都会使用递归的方式解决

• 对于本题，我们可以想到DFS来遍历整棵树，然后记录其最小深度

因此，我们需要递归计算每一个非叶子节点的左右子树深度，取其最小值

本题的递归条件分析如下：

• 如果根节点为空，直接返回0
• 如果左右孩子都为空，说明已经到叶子节点，返回1
• 如果左右孩子有一个为空，返回其不为空孩子节点的深度
• 如果左右孩子都不为空，求左右孩子节点深度的较小值

代码实现 DFS

public int minDepth3(TreeNode root)
{
    //1.如果根节点为0，直接返回0
    if (root == null)
    {
        return 0;
    }

    //2.左孩子和有孩子都为空的情况，说明到达了叶子节点，直接返回1即可
    if (root.left == null & root.right == null)
    {
        return 1;
    }

    //3.如果左右孩子均不为空，返回较小的
    int leftDepth = minDepth(root.left);//计算左子树深度
    int rightDepth = minDepth(root.right);//计算右子树深度
    if (root.left == null || root.right == null)
    {
        return leftDepth + rightDepth + 1;//如果有一个为空，肯定深度为0，加上也不影响
    }

    //4.如果左右孩子都不为空，返回左右孩子的深度的较小值
    return Math.min(leftDepth, rightDepth) + 1;
}

简化版

对于递归结束条件2，如果左右孩子都为空

带入递归结束条件3后，leftDepth + rightDepth + 1=0+0+1=1

我们可以发现，结果与条件2相同所以可以将其合并

public int minDepth3(TreeNode root)
{
    //1.如果根节点为0，直接返回0
    if (root == null)
    {
        return 0;
    }

    //2 3.如果左右孩子有一个不为空，返回较小的
    int leftDepth = minDepth(root.left);//计算左子树深度
    int rightDepth = minDepth(root.right);//计算右子树深度
    if (root.left == null || root.right == null)
    {
        return leftDepth + rightDepth + 1;//如果有一个为空，肯定深度为0，加上也不影响
    }

    //4.如果左右孩子都不为空，返回左右孩子的深度的较小值
    return Math.min(leftDepth, rightDepth) + 1;
}

代码实现BFS

当我们找到一个叶子节点时，直接返回这个叶子节点的深度。广度优先搜索的性质保证了最先搜索到的叶子节点的深度一定最小。

• 创建队列中节点类（树节点 及 该节点深度）
• 使用队列保存每一层元素

class QueueNode
{
    TreeNode node;//树节点内容
    int depth;//当前节点深度

    public QueueNode(TreeNode node, int depth)
    {
        this.node = node;
        this.depth = depth;
    }
}

public class Main
{
    public int minDepth(TreeNode root)
    {
        //如果根节点为空，直接返回0
        if (root == null)
        {
            return 0;
        }
        //创建队列
        LinkedList<QueueNode> queue = new LinkedList<>();
        //根节点入队列
        queue.offer(new QueueNode(root, 1));
        while (!queue.isEmpty())
        {
            //取出当前队列节点
            QueueNode nodeDepth = queue.poll();
            //取出树节点的元素
            TreeNode node = nodeDepth.node;
            //取出树节点的深度
            int depth = nodeDepth.depth;
            //如果左右子树都为空，说明到了叶子节点，直接返回当前深度
            if (node.left == null && node.right == null)
            {
                return depth;
            }
            //如果左孩子不为空，将其入队，并且其深度为当前深度+1
            if (node.left != null)
            {
                queue.offer(new QueueNode(node.left, depth + 1));
            }
            //如果右孩子不为空，将其入队，并且其深度为当前深度+1
            if (node.right != null)
            {
                queue.offer(new QueueNode(node.right, depth + 1));
            }
        }
        return 0;
    }
}

二叉树的

题目描述

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

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

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

分析

同样使用DFS及BFS

代码实现 DFS

public int maxDepth(TreeNode root)
{
    //如果根节点为空，直接返回0
    if (root == null)
    {
        return 0;
    }
    //如果左右孩子都为空，说明是叶节点，返回1
    if (root.left == null && root.right == null)
    {
        return 1;
    }
    //递归求左右孩子最大深度
    int maxLeft = maxDepth(root.left);
    int maxRight = maxDepth(root.right);
    //返回左右孩子深度最大值+1（当前层）
    return Math.max(maxLeft, maxRight) + 1;
}

代码实现 BFS

• 用队列保存每一层元素
• 当队列不为空时，需要将队列里的**所有节点（当前层节点）**都拿出来进行判断
• 如果有左右孩子，说明其有下一层节点，将其入队列
• 最后我们用一个变量 depth 来维护拓展的次数，该二叉树的最大深度即为 depth。

public int maxDepth(TreeNode root)
{
    //如果根节点为空，直接返回0
    if (root == null)
    {
        return 0;
    }
    //创建保存本层节点的队列
    Queue<TreeNode> queue = new LinkedList<>();
    //首先将根节点入队列
    queue.add(root);
    //记录对大深度
    int depth = 0;
    //当队列不为空，说明还有一层，循环
    while (!queue.isEmpty())
    {
        //获取本层元素个数
        int size = queue.size();
        //当本层还有元素，添加其左右孩子带队列（即下一层元素）
        while (size > 0)
        {
            //获取当前元素
            TreeNode curNode = queue.poll();
            if (curNode.left != null)
            {
                queue.add(curNode.left);
            }
            if (curNode.right != null)
            {
                queue.add(curNode.right);
            }
            //本层元素数量减1
            size--;
        }
        //结束一层循环说明深度+1
        depth++;
    }
    return depth;
}