代码随想录算法训练营第16天 | LeetCode 104.二叉树的最大深度， 559.n叉树的最大深度，111.二叉树的最小深度，222.完全二叉树的节点个数

已于 2023-01-14 22:04:43 修改
阅读量198 收藏
点赞数
分类专栏： 代码随想录训练营 文章标签： leetcode 算法 数据结构
于 2022-11-10 11:11:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a976903676/article/details/127785234
版权

LeetCode [104. 二叉树的最大深度]

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

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

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

示例：
给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

思路：

//递归法
/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        int leftDepth = maxDepth(root.left);
        int rightDepth = maxDepth(root.right);
        return Math.max(leftDepth,rightDepth) + 1;
    }
}

//BFS
/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        Deque<TreeNode> res = new LinkedList<>();
        int depth = 0;
        res.offer(root);
        while(!res.isEmpty()){
            int currentLevelSize = res.size();
            for(int i = 0;i < currentLevelSize;i++){
                TreeNode node = res.poll();
                if(node.left != null){
                    res.offer(node.left);
                }
                if(node.right != null){
                    res.offer(node.right);
                }
            }
            depth++;
        }
        return depth;
    }
}

LeetCode [559. N 叉树的最大深度]

题目：给定一个 N 叉树，找到其最大深度。

最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。

N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。

示例 1：

img

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

示例 2：

img

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：5

提示：

  • 树的深度不会超过 1000 。
  • 树的节点数目位于 [0, 104] 之间。

思路：

//递归法
/*
// Definition for a Node.
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;
    }
};
*/

class Solution {
    public int maxDepth(Node root) {
        if(root == null){
            return 0;
        }
        int depth = 0;
        if(root.children != null){
            for(Node child : root.children){
                depth = Math.max(depth,maxDepth(child));
            }
        }
        return depth + 1;
    }
}

//层序遍历
/*
// Definition for a Node.
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;
    }
};
*/

class Solution {
    public int maxDepth(Node root) {
        if(root == null){
            return 0;
        }
        Deque<Node> res = new LinkedList<>();
        int depth = 0;
        res.offer(root);
        while(!res.isEmpty()){
            depth++;
            int currentLevelSize = res.size();
            while(currentLevelSize-- > 0){
                Node node = res.poll();
                for(Node c : node.children){
                    if(c != null){
                        res.offer(c);
                    }
                }
            }
        }
        return depth;
    }
}

LeetCode [111. 二叉树的最小深度]

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

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

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

示例 1：

img

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

示例 2：

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

提示：

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

思路：

//递归法
/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        int leftDepth = minDepth(root.left);
        int rightDepth = minDepth(root.right);
        //如果左子树为空，右子树不为空，则最小深度是右子树深度 + 1
        if(root.left == null && root.right != null){
            return rightDepth + 1;
        }
        //如果右子树为空，左子树不为空，则最小深度是左子树深度 + 1
        if(root.left != null && root.right == null){
            return leftDepth + 1;
        }
        return Math.min(leftDepth,rightDepth) + 1;
    }
}

//层序遍历
/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        Deque<TreeNode> res = new LinkedList<>();
        res.offer(root);
        int depth = 0;
        while(!res.isEmpty()){
            int currentLevelSize = res.size();
            depth++;
            while(currentLevelSize-- > 0){
                TreeNode node = res.poll();
                if(node.left == null && node.right == null){
                    return depth;
                }
                if(node.left != null){
                    res.offer(node.left);
                }
                if(node.right != null){
                    res.offer(node.right);
                }
            }
        }
        return depth;
    }
}

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

题目：给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

示例 1：

img

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

示例 2：

输入：root = []
输出：0

示例 3：

输入：root = [1]
输出：1

提示：

  • 树中节点的数目范围是[0, 5 * 104]
  • 0 <= Node.val <= 5 * 104
  • 题目数据保证输入的树是 完全二叉树

**进阶：**遍历树来统计节点是一种时间复杂度为 O(n) 的简单解决方案。你可以设计一个更快的算法吗？

思路：

//层序遍历
/**
 * Definition for a binary tree node.
 * 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;
 * }
 * }
 */
class Solution {
    public int countNodes(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Deque<TreeNode> res = new LinkedList<>();
        res.offer(root);
        int count = 0;
        while (!res.isEmpty()) {
            int currentLevelSize = res.size();
            count += currentLevelSize;
            while (currentLevelSize-- > 0) {
                TreeNode node = res.poll();
                if (node.left != null) {
                    res.offer(node.left);
                }
                if (node.right != null) {
                    res.offer(node.right);
                }
            }
        }
        return count;
    }
}

//递归法
/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    public int countNodes(TreeNode root) {
        if(root == null){
            return 0;
        }
        return countNodes(root.left) + countNodes(root.right) + 1;
    }
}
XnyuDo
关注
专栏目录
leetcode 104. 二叉树的最大深度（C++）
12-22
python版——>leetcode 104：二叉树的最大深度(python) 文章目录题目层次遍历法递归法 题目 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有...
hackerchenzhuo#ccf_pat_leetcode.etc#leetcode 111. 二叉树的最小深度1
07-25
原创：leetcode 111. 二叉树的最小深度记住：最小深度和最大深度方法不同。* Definition for a binary tree node.in
leetcode-4.28[107. 二叉树的层次遍历 II、101. 对称二叉树、104. 二叉树的最大深度]（python解法）
01-20
题目1 原创文章 81获赞 40访问量 3万+ 关注 私信 展开阅读全文 作者：Leadingme
java-leetcode题解之第104题二叉树的最大深度.zip
06-18
综上所述，这个压缩包中的内容可能包含了一个使用Java编写的程序，该程序实现了递归或层次遍历算法，以解决LeetCode第104题——计算给定二叉树的最大深度。这为学习者提供了一个实际应用Java处理二叉树问题的实例，...
php-leetcode题解之二叉树的最大深度.zip
06-08
在本压缩包“php-leetcode题解之二叉树的最大深度.zip”中，主要涵盖了使用PHP语言解决LeetCode上的一个经典算法问题——“二叉树的最大深度”。LeetCode是一个在线平台，提供了各种编程挑战，旨在提升程序员的技能...
【LeetCode】70.爬楼梯
weixin_63135906的博客
11-13 455
我们从最后一级台阶n开始分析，有两种方法可以上去，n-1爬一次即可，n-2需要两个台阶即可到达第n个台阶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？提交不能通过，超出时间限制了，时间复杂度是O（2^n）在vscode里运行是没有问题的，放到力扣里就报错了。需要 n 阶你才能到达楼顶。当前层爬楼梯方法数等于前两层爬楼梯数相加。注意：给定 n 是一个正整数。： 有两种方法可以爬到楼顶。： 有三种方法可以爬到楼顶。
leetcode LCR 068 搜索插入位置
qq_73454087的博客
11-14 769
已解答简单相关标签相关企业给定一个排序的整数数组nums和一个整数目标值target，请在数组中找到target，并返回其下标。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。请必须使用时间复杂度为O(log n)的算法。21400。
力扣 LeetCode 239. 滑动窗口最大值（Day5：栈与队列）
qq_61504864的博客
11-15 264
可以把 peek() 改为 peekFirst() ，虽然是一个意思，但看起来更加清楚，对于双端队列能更清晰地表述具体操作。始终维护deque的头元素为最大值，后面来的值更大就会逐一清除前面比它小的值。
Leetcode 3356. Zero Array Transformation II
最新发布
codename_cys的博客
11-17 329
Leetcode 3356. Zero Array Transformation II
LeetCode:448找到所有数组中消失的数字——Java哈希表&布尔数组
2301_78566776的博客
11-16 426
最直观的思路是使用哈希集合存储数组 nums 中出现的所有整数，然后遍历 1 到 n 的每个整数并判断是否在哈希集合中，如果一个整数不在哈希集合中则该整数是消失的数字，将该整数添加到结果中。中的数字，并以数组的形式返回结果。数组中对应索引位置的值设置为。如果某个索引位置的值是。中未出现，将其添加到结果列表。，则表示该索引（即数字）在。，表示该索引（即数字）在。
【JavaScript】LeetCode：96-100
weixin_45980065的博客
11-15 999
【代码】【JavaScript】LeetCode：96-100。
力扣经典面试题
HandsomeBoyqxc的博客
11-15 314
3.然后遍历ransomNote字符串，对于其中的每个字符，检查它是否在char_count字典中且对应的计数大于0。如果不满足条件（字符不在字典中或者计数已经为0），就说明无法用magazine中的子粗构成ransomNote,直接返回false。1.本题的目标是判断字符串ransomNote是否由字符串magazine中的字符构成，且由magazine中的每个字符只能在ransomNote中使用一次。对于 ransomNote 中的每个字符char，先检查它是否在 字典中，并且该字符在。
力扣 LeetCode 18. 四数之和（Day3：哈希表）
qq_61504864的博客
11-13 212
四数之和：指针 k ，i ，left ，right（相当于多了一个 k ，多了一个外层 for 循环）需要注意剪枝操作，因为给的是target，target不一定是正数，所以要额外有值>=0的判断。三数之和：指针 i ，left ，right。需要先弄懂三数之和，思路类似。
leetcode104：二叉树的最大深度
D2510466299的博客
11-14 344
给定一个二叉树root，返回其最大深度。二叉树的是指从根节点到最远叶子节点的最长路径上的节点数。32[0, 104]
leetcode-位运算题型
weixin_44965579的博客
11-14 415
力扣位运算
力扣 多数元素-169
Sunyanhui1的博客
11-17 397
在C++中，内联函数是一种特殊的函数，通过在函数定义前添加inine关键字来声明。例如编译器在处理内联函数时，会尝试将函数调用出直接替换为函数体的代码，而不是像普通的函数那样进行函数调用的开销（如保存当前函数的执行上下文、跳转到被调用函数的入口地址、执行完后再返回等操作）。普通函数：当调用普通函数时，程序需要执行一系列操作，如保存当前函数的执行上下文（包括寄存器的值、当前指令指针等），将参数压栈，跳转到被调用函数的入口地址，执行被调用函数的代码，最后在函数返回时恢复之前保存的执行上下文。
力扣题目解析--有效的括号
wxtg1921的博客
11-13 1049
学者在最初接触的这道题的时候，刚开始的想法就是利用地图查找法来进行匹配，但是那样写的代码太过于臃肿，而且出了问题。然后经过学习，认为地图查找法可以使用，但是需要辅助。于是利用栈来辅助判断括号。1.栈（下面来详细介绍一下占数组之间有何特点和优点，这样可以帮助我们更加正确的认识这样的使用，在以后解决问题的过程中，我们可以正确的使用栈的特点和优点。如果是左括号，它会在。提供的一个成员函数，用于检查键。，判断字符串是否有效。中找到对应的右括号。
Golang | Leetcode Golang题解之第565题数组嵌套
weixin_66442839的博客
11-17 561
Golang | Leetcode Golang题解之第565题数组嵌套
leetcode面试 150题之 三数之和 复刷日记
weixin_72492465的博客
11-13 128
这里我们选择了一个值后 再去通过双指针找与该值到和为0的二元组，这里的去重就简单了，已经固定了一个值，这里的二元组只要有一个和之前的相等则指针相应的++或者--直到找不到二元组和固定值为相反数为止。然后我尝试只固定一个值，因为上面的 -4 -2 -2 0 2 2 4 中就是因为我锁定l,r导致无论是l++,还是r--都会丢掉一个解。这里代码只能处理一半的数据 当遇到 -4 -2 -2 0 2 2 4时就漏情况了，而且处理起来非常麻烦。我先想到的是双指针固定两个数然后二分找第三个数(有点想当然)
LeetCode算法题：二叉树最大深度与二维数组表示
内容涉及二叉树的深度计算以及如何将二叉树转换为二维数组形式进行展示，通过具体的JavaScript函数实现这两种算法，体现了递归在树形结构问题中的应用。" 知识点一：二叉树的概念与递归遍历 在计算机科学中，二叉树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值