算法训练营day15|104.二叉树的最大深度,111.二叉树的最小深度,222.完全二叉树的节点数

已于 2023-11-06 22:36:34 修改
阅读量78 收藏
点赞数
文章标签： java
于 2023-11-05 22:50:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TS_xiaolei/article/details/134236455
版权

知识点

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

而根节点的高度就是二叉树的最大深度

二叉树根节点的高度:使用后序遍历

二叉树的最大深度:使用前序遍历

刷题

104.二叉树的最大深度

LeetCode链接 104. 二叉树的最大深度 - 力扣（LeetCode）

题目描述

方法1:bfs+队列

package daimasuixiangshuati.day14_erchashu;

import java.util.LinkedList;

/**
 * @Author LeiGe
 * @Date 2023/11/5
 * @Description todo
 */
public class ErChaShuDeZuiDaShengDu104_2 {

    /**
     * 方法1:bfs-队列
     * 1.通过层序遍历,计算有多少层即可
     *
     * @param root
     * @return
     */
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.addLast(root);
        int num = 0;
        while (!queue.isEmpty()) {
            //队里中维护的是每层的所有节点,size就是这层有多少个节点
            int size = queue.size();
            while (size > 0) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    queue.addLast(node.left);
                }
                if (node.right != null) {
                    queue.addLast(node.right);
                }
                size--;
            }
            //遍历完一层+1
            num++;
        }
        return num;
    }

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

方法2:dfs+递归

package daimasuixiangshuati.day14_erchashu;

/**
 * @Author LeiGe
 * @Date 2023/11/5
 * @Description todo
 */
public class ErChaShuDeZuiDaShengDu104_3 {

    /**
     * 方法2:dfs+递归
     * 1.递归记录左子树对应的最大深度
     * 2.递归记录右子树对应的最大深度
     * 3.取左右子树的最大值
     *
     * @param root
     * @return
     */
    public int maxDepth(TreeNode root) {
        int maxDep = 0;
        return dfs(root, maxDep);
    }

    private int dfs(TreeNode root, int maxDep) {
        // baseCase
        if (root == null) {
            return 0;
        }

        // 左边的最大深度
        int left = dfs(root.left, maxDep);

        // 右边的最大深度
        int right = dfs(root.right, maxDep);

        // 取左右两边的最大值,再加上本层
        maxDep = Math.max(left, right) + 1;

        return maxDep;
    }

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

599.n叉树的最大深度

LeetCode链接 559. N 叉树的最大深度 - 力扣（LeetCode）

题目描述

方法1:bfs+队列

package daimasuixiangshuati.day15_erchashu;

import java.util.ArrayDeque;
import java.util.List;

/**
 * @Author LeiGe
 * @Date 2023/11/6
 * @Description todo
 */
public class NChaShuDeZuiDaShenDu559_2 {

    /**
     * 方法1:bfs-队列
     * 1.层序遍历,计算有多少层,就是最大深度
     * 2.队列中维持的是每层所有的节点
     * 3.队列中元素出队列,将出队列的元素的所有child加入的队列中
     *
     * @param root
     * @return
     */
    public int maxDepth(Node root) {
        return bfs(root);
    }

    private int bfs(Node root) {
        if (root == null) {
            return 0;
        }
        ArrayDeque<Node> queue = new ArrayDeque<>();
        int depth = 0;
        queue.addLast(root);
        while (!queue.isEmpty()) {
            depth++;//计算深度
            //队列大小就是这层节点数的大小
            int size = queue.size();

            //遍历这层的所有节点
            for (int i = 0; i < size; i++) {
                Node node = queue.pollFirst();
                //将出队列元素的所有child加入到队列中
                if (node.children != null) {
                    int childSize = node.children.size();
                    for (int j = 0; j < childSize; j++) {
                        queue.addLast(node.children.get(j));
                    }
                }
            }
        }
        return depth;
    }

    class Node {
        public int val;
        public List<Node> children;

        public Node() {
        }

        public Node(int _val) {
            val = _val;
        }

        public Node(int _val, List<Node> _children) {
            val = _val;
            children = _children;
        }
    }

    ;

}

方法2:dfs+递归

package daimasuixiangshuati.day15_erchashu;

import java.util.ArrayDeque;
import java.util.List;

/**
 * @Author LeiGe
 * @Date 2023/11/6
 * @Description todo
 */
public class NChaShuDeZuiDaShenDu559_3 {
    /**
     * 方法2:dfs-递归
     * 0.中序遍历
     * 1.递归获取所有child的最大深度
     * 2.选出最大的一个
     * 3.最大深度+1就是本节点的最大深度
     *
     * @param root
     * @return
     */
    public int maxDepth(Node root) {
        return dfs(root);
    }

    private int dfs(Node root) {
        if (root == null) {
            return 0;
        }

        //获取root节点所有child的最大深度
        int childSize = root.children.size();
        int[] childDepths = new int[childSize];
        for (int i = 0; i < childSize; i++) {
            Node child = root.children.get(i);
            int childDepth = dfs(child);
            childDepths[i] = childDepth;
        }

        //从所有child的最大深度中选出最大的一个
        int childMaxDepth = 0;
        for (int childDepth : childDepths) {
            if (childDepth > childMaxDepth) {
                childMaxDepth = childDepth;
            }
        }
        return childMaxDepth + 1;
    }

    class Node {
        public int val;
        public List<Node> children;

        public Node() {
        }

        public Node(int _val) {
            val = _val;
        }

        public Node(int _val, List<Node> _children) {
            val = _val;
            children = _children;
        }
    }
}

111.二叉树的最小深度

LeetCode链接 111. 二叉树的最小深度 - 力扣（LeetCode）

题目描述

方法1:bfs+队列

package daimasuixiangshuati.day14_erchashu;

import java.util.ArrayDeque;

/**
 * @Author LeiGe
 * @Date 2023/11/5
 * @Description todo
 */
public class ErChaShuDeZuiXiaoShenDu111_2 {

    /**
     * 方法2:bfs-队列
     * 1.层序遍历
     * 2.当左右孩子都为null的时候,说明到了最低点,有一个孩子不为null,则不是最低点
     *
     * @param root
     * @return
     */
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }

        int depth = 0;
        ArrayDeque<TreeNode> queue = new ArrayDeque<>();
        queue.addLast(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            // 记录最小深度
            depth++;

            for (int i = 0; i < size; i++) {
                TreeNode node = queue.pollFirst();
                if (node.left != null) {
                    queue.addLast(node.left);
                }
                if (node.right != null) {
                    queue.addLast(node.right);
                }
                if (node.left == null && node.right == null) {
                    // 当左右孩子都为空的时候，说明是最低点的一层了，退出
                    return depth;
                }
            }
        }
        return depth;
    }

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

方法2:dfs+递归

package daimasuixiangshuati.day14_erchashu;

import java.util.ArrayDeque;

/**
 * @Author LeiGe
 * @Date 2023/11/5
 * @Description todo
 */
public class ErChaShuDeZuiXiaoShenDu111_3 {

    /**
     * 方法1:dfs-递归,后序遍历
     * 1.注意要到达叶子节点
     * 2.注意左子树为null,右子树不为null的情况
     * 3.注意右子树为null,左子树不为null的情况
     *
     * @param root
     * @return
     */
    public int minDepth(TreeNode root) {
        return dfs(root);
    }

    private int dfs(TreeNode root) {
        if (root == null) {
            return 0;
        }

        int leftMinDep = dfs(root.left);
        int rightMinDep = dfs(root.right);

        //左子树为null,右子树不为null
        if (root.left == null && root.right != null) {
            return rightMinDep + 1;
        }
        //右子树为null,左子树不为null
        if (root.right == null && root.left != null) {
            return leftMinDep + 1;
        }

        return Math.min(leftMinDep, rightMinDep) + 1;
    }

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

222.完全二叉树的节点个数

LeetCode链接 222. 完全二叉树的节点个数 - 力扣（LeetCode）

题目描述

方法1:普通二叉树节点个数-dfs+递归

package daimasuixiangshuati.day15_erchashu;

/**
 * @Author LeiGe
 * @Date 2023/11/6
 * @Description todo
 */
public class WanQuanErChaShuDeJieDianGeShu222_1 {

    /**
     * 普通二叉树的节点个数:
     * 方法1:dfs+递归
     * 本节点个数=左子树节点个数+右子树节点个数+1
     *
     * @param root
     * @return
     */
    public int countNodes(TreeNode root) {
        return dfs1(root);
    }

    private int dfs1(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int left = dfs1(root.left);
        int right = dfs1(root.right);
        return (left + right) + 1;
    }

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

}

方法2:普通二叉树节点个数-bfs+队列

package daimasuixiangshuati.day15_erchashu;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @Author LeiGe
 * @Date 2023/11/6
 * @Description todo
 */
public class WanQuanErChaShuDeJieDianGeShu222_2 {

    /**
     * 普通二叉树的节点个数:
     * 方法2:bfs+队列
     * 层序遍历,每处理一个节点,统计节点个数的变量值+1
     *
     * @param root
     * @return
     */
    public int countNodes(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int result = 0;
        while (!queue.isEmpty()) {
            int size = queue.size();
            while (size-- > 0) {
                TreeNode cur = queue.poll();
                result++;
                if (cur.left != null) {
                    queue.offer(cur.left);
                }
                if (cur.right != null) {
                    queue.offer(cur.right);
                }
            }
        }
        return result;
    }

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

}

方法3:完全二叉树节点个数-递归

package daimasuixiangshuati.day15_erchashu;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @Author LeiGe
 * @Date 2023/11/6
 * @Description todo
 */
public class WanQuanErChaShuDeJieDianGeShu222_3 {

    /**
     * 完全二叉树的节点个数:根据完全二叉树的性质独有的解法
     * 完全二叉树只有两种情况,情况一:是二叉树,情况二:最有一层叶子节点没有满
     * 对于情况一:可以直接通过2^树深度-1来计算总个数
     * 对于情况二:分别递归左孩子和右孩子,递归到某一深度一定会有左孩子或者右孩子为满二叉树,这时就可以按照情况一来计算了
     * 如何判断一颗树不是满二叉树呢?
     * 在完全二叉树中,如果递归向左遍历的深度等于递归向右的深度,那么就说明这颗树是满二叉树
     *
     * @param root
     * @return
     */
    public int countNodes(TreeNode root) {
        if (root == null) {
            return 0;
        }

        // 左右子树
        TreeNode left = root.left;
        TreeNode right = root.right;

        // 初始化树的深度为1,此时处理的节点
        int leftDepth = 1;
        int rightDepth = 1;

        // 计算左侧的深度
        while (left != null) {
            left = left.left;
            leftDepth++;
        }

        // 计算右侧的深度
        while (right != null) {
            right = right.right;
            rightDepth++;
        }

        // 如果左右深度深度说明是满二叉树,直接计算
        if (leftDepth == rightDepth) {
            return (int) Math.pow(2, leftDepth) - 1;
        }

        // 否则递归处理左右子树,直到他们都为满二叉树
        return countNodes(root.left) + countNodes(root.right) + 1;
    }

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

}

小结

天上小雷
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
leetcode 104. 二叉树的最大深度（C++）
12-22
python版——>leetcode 104：二叉树的最大深度(python) 文章目录题目层次遍历法递归法 题目 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有...
johanazhu#leetcode#【Day 13 】2021-05-22 - 104. 二叉树的最大深度1
07-25
题目地址：思路这个题简单，使用二叉树，先循环左边的，再循环右边的，递归思想代码* Definition for a binary tree node.* fun
代码随想录算法训练营 DAY 16 | 104.二叉树最大深度 111.二叉树最小深度 222.完全二叉树的节点个数
qq_35904005的博客
03-21 885
把左和右递归遍历的操作放到一个for循环里，遍历node.children 得到depth，最后return depth+1即可！对于情况二，分别递归左孩子，和右孩子，递归到某一深度一定会有左孩子或者右孩子为满二叉树，然后依然可以按照情况1来计算。核心思路：利用完全二叉树特性，因为题目是完全二叉树，直接全部遍历左孩子和右孩子，如果高度相等它就是满二叉树，直接。完全二叉树只有两种情况，情况一：就是满二叉树，情况二：最后一层叶子节点没有满。前序遍历和后序遍历都可以，前序求的是深度，后序求的是高度。
代码随想录算法训练营Day16 | 104. 二叉树的最大深度 | 111. 二叉树的最小深度 | 222. 完全二叉树的节点个数
Kolbe_Huang的博客
07-28 138
对于完全二叉树而言，寻找到满二叉子树即可通过公式直接计算该树内的节点数量，并向父节点传递。这道题的递归终止条件比较复杂，当找到了满二叉子树的时候也应该直接返回（这也是低复杂度的来源，跳过了搜索所有满二叉子树的内部节点）。非常相似（高度是根节点到叶子节点的最远路径），所以还是可以后序遍历，从而得到最小深度。要小心的是对于空节点的处理，在后序解法中 None 是没可能成为叶子节点的，但却拥有最小的深度。：除了最后一层都是满的，最后一层的节点尽可能靠左分布。自己的前序遍历解法，和二叉树的几乎一模一样。
代码随想录算法训练营 day16 || 104. 二叉树的最大深度，111.二叉树的最小深度，222. 完全二叉树节点的个数
旭
01-11 445
由于深度遍历是以深度为驱动，逐一的遍历完树上的所有路径，因此对于发掘最靠近根结点的叶子节点，深度遍历中需要设置全局变量来不断更新当访问到叶子节点时所处在的深度，那么次数深度遍历的参数中就需要加上 deep 或 floor 这一表示高度的参数，定义全局变量没有用，因此你无法再递归中做到仅仅在进入该层的第一次中对 floor 全局变量进行加1。此外统计最小高度的变量不是全局变量，那么深度优先对路径遍历的优先，将导致最后返回的深度不一定是最靠近根结点的叶子节点所处在的高度。思路：三种方法，深度遍历记录节点个数；
算法训练营DAY16|104.二叉树的最大深度、111.二叉树的最小深度、222.完全二叉树的节点个数
weixin_59867637的博客
12-23 114
leetcode104.二叉树的最大深度、111.二叉树的最小深度、222.完全二叉树的节点个数
代码随想录算法训练营day16 | 104.二叉树的最大深度、111.二叉树的最小深度、222.完全二叉树的节点个数
sunflowers11的博客
01-25 223
本次全部使用递归的方式实现。
代码随想录算法训练营day19 | 104.二叉树的最大深度、111.二叉树的最小深度、222.完全二叉树的节点个数
sunflowers11的博客
05-10 301
本题可以使用前序（中左右），也可以使用后序遍历（左右中），使用前序求的就是深度，使用后序求的是高度。根节点的高度就是二叉树的最大深度，所以本题可以通过后序求根节点高度来求的二叉树最大深度。
算法训练营笔记day16|104. 二叉树的最大深度、111. 二叉树的最小深度、222. 完全二叉树的节点个数
weixin_45662787的博客
03-16 60
判断当前节点以下是否为满二叉树，若是则返回满二叉树的节点的个数，若不是，则递归的遍历左子树和右子树。只有当一个节点的左右子树都为NULL时，这个节点才是叶节点。层序遍历，递归都可以。
代码随想录算法训练营Day16 | 104.二叉树的最大深度 559.n叉树的最大深度 111.二叉树的最小深度 222.完全二叉树的节点个数
qq_24817679的博客
04-18 244
思路：递归法与层序法。
代码随想录算法训练营day16| 104.二叉树的最大深度、111.二叉树的最小深度、222.完全二叉树的节点个数
weixin_45368277的博客
12-26 1318
二叉树的遍历
JPNW.rar_C 二叉树算法_人工智能/神经网络/深度学习
09-20
本压缩包文件“JPNW.rar”包含了与C++编程语言相关的二叉树算法实现，是学习数据结构和算法的宝贵资源，特别是对于那些对人工智能、神经网络或深度学习感兴趣的开发者。 二叉树是一种特殊的图结构，每个节点最多有...
leetcode-4.28[107. 二叉树的层次遍历 II、101. 对称二叉树、104. 二叉树的最大深度]（python解法）
01-20
题目1 原创文章 81获赞 40访问量 3万+ 关注 私信 展开阅读全文 作者：Leadingme
配置Java开发环境
Broken_x的博客
07-10 1463
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
最新发布
baina666的博客
07-12 357
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 428
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2332
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值