day16第六章二叉树（二刷）

最新推荐文章于 2024-10-15 19:28:18 发布
最新推荐文章于 2024-10-15 19:28:18 发布
阅读量115 收藏
点赞数
分类专栏： 力扣刷题 文章标签： leetcode 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48668772/article/details/128672827
版权
这篇博客主要介绍了LeetCode中与树的最大深度相关的四道题目：104.二叉树的最大深度、559.n叉树的最大深度、111.二叉树的最小深度和222.完全二叉树的节点个数。通过解题代码深入理解二叉树和n叉树的深度计算，同时讲解了递归解题的三部曲。
摘要由CSDN通过智能技术生成

今日任务

  • 104.二叉树的最大深度
  • 559.n叉树的最大深度
  • 111.二叉树的最小深度
  • 222.完全二叉树的节点个数

104.二叉树的最大深度

题目链接：

https://leetcode.cn/problems/maximum-depth-of-binary-tree/description/

题目描述：

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

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

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

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

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

题解代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
//二刷：使用了 迭代法法 层序遍历的方式
//问题转化：求最大深度=二叉树有几层。
    int maxDepth(TreeNode* root) {
        if(root == NULL){
            return 0;
        }

        queue<TreeNode*> que;
        int depth = 0;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            depth++;
            for(int i = 0; i < size; i++){
                TreeNode* cur = que.front();
                que.pop();
                if(cur->left){
                    que.push(cur->left);
                }
                if(cur->right){
                    que.push(cur->right);
                }
            }
        }
        return depth;
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
//一刷：使用了 递归法 后序遍历的方式
    int getHeight(TreeNode* node){
        //根结点的高度就是 二叉树的最大深度
        //使用后序遍历求根结点的高度

        if(node==NULL){
            return 0;
        }

        //左
        int leftHeight = getHeight(node->left);
        //右
        int rightHeight = getHeight(node->right);

        //根结点
        int height = 1+max(leftHeight,rightHeight);

        return height;

    }

    int maxDepth(TreeNode* root) {
        int maxD = getHeight(root);

        return maxD;
    }
};

559.n叉树的最大深度

题目链接：

https://leetcode.cn/problems/maximum-depth-of-n-ary-tree/description/

题目描述：

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

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

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

示例 1：

https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png

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

示例 2：

https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png

输入：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;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    int maxDepth(Node* root) {
        //递归法
        if(root == NULL){
            return 0;
        }
        int depth = 0;
        for(int i= 0; i < root->children.size();i++){
            depth = max(depth,maxDepth(root->children[i]));
        }
        return depth+1;
    }
};

111.二叉树的最小深度

题目链接：

https://leetcode.cn/problems/minimum-depth-of-binary-tree/description/

题目描述：

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

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

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

示例 1：

https://assets.leetcode.com/uploads/2020/10/12/ex_depth.jpg

输入：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

题解代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    //二刷： 使用迭代法
    int minDepth(TreeNode* root) {
        if(root == NULL){
            return  0;
        }
        queue<TreeNode*> que;
        que.push(root);
        int depth = 0;
        while(!que.empty()){
            int size = que.size();
            depth++;
            for(int i = 0; i < size;i++){
                TreeNode* cur = que.front();
                que.pop();
                if(cur->left){
                    que.push(cur->left);
                }
                if(cur->right){
                    que.push(cur->right);
                }
                if(!cur->left && !cur->right){
                    return depth;
                }
            }
        }
        return depth;

    }

//一刷 ：递归法
/*
    int getHeight(TreeNode* node){
        if(node == NULL){
            return 0;
        }
        //左
        int leftHeight = getHeight(node->left);
        //右
        int rightHeight = getHeight(node->right);

        //有两种特殊情况需要处理
        //当左子树为空，右子树不为空
        if(node->left==NULL && node->right!=NULL){
            return 1+rightHeight;
        }
        //当左子树不为空，右子树为空
        if(node->left!=NULL && node->right==NULL){
            return 1+leftHeight;
        }

        //中
        int height = 1 + min(leftHeight,rightHeight);

        return height;
    }
    int minDepth(TreeNode* root) {
        int res = getHeight(root);
        return res;
    }
    */
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
//一刷 ：递归法
    int getHeight(TreeNode* node){
        if(node == NULL){
            return 0;
        }
        //左
        int leftHeight = getHeight(node->left);
        //右
        int rightHeight = getHeight(node->right);

        //有两种特殊情况需要处理
        //当左子树为空，右子树不为空
        if(node->left==NULL && node->right!=NULL){
            return 1+rightHeight;
        }
        //当左子树不为空，右子树为空
        if(node->left!=NULL && node->right==NULL){
            return 1+leftHeight;
        }

        //中
        int height = 1 + min(leftHeight,rightHeight);

        return height;
    }
    int minDepth(TreeNode* root) {
        int res = getHeight(root);
        return res;
    }
};

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

题目链接：

https://leetcode.cn/problems/count-complete-tree-nodes/description/

题目描述：

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

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

示例 1：

https://assets.leetcode.com/uploads/2021/01/14/complete.jpg

输入：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.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    
    int countNodes(TreeNode* root){
        if(root == NULL){
            return 0;
        }
        TreeNode* leftNode = root->left;
        TreeNode* rightNode = root->right;
        int leftDepth = 0;
        int rightDepth = 0;
        while(leftNode){
            leftNode = leftNode->left;
            leftDepth++;
        }
        while(rightNode){
            rightNode = rightNode->right;
            rightDepth++;
        }
        if(leftDepth == rightDepth){
            return (2<<leftDepth)-1;//2<<3 = 2的2次方;
        }
        return countNodes(root->left)+countNodes(root->right)+1;
    }

    //一刷
    /*
    int countNodes(TreeNode* root) {
        //大思路：后序遍历

        //处理终止条件
        if(root==NULL){
            return 0;
        }

        //判断子树是否是满二叉树
        int leftDepth = 0;
        int rightDepth = 0;
        TreeNode* leftN = root->left;
        TreeNode* rightN = root->right;

        //统计左子树深度
        while(leftN){
            leftN=leftN->left;
            leftDepth++;
        }

        //统计右子树深度
        while(rightN){
            rightN = rightN->right;
            rightDepth++;
        }
        if(leftDepth==rightDepth){
            return (2<<leftDepth)-1;//2<<3 = 2的2次方
        }

        //递归单层逻辑
        //处理左
        int leftNum = countNodes(root->left);
        //处理右
        int rightNum = countNodes(root->right);
        //处理中
        int num = leftNum+rightNum+1;

        return num;
    }
    */
};

总结

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

递归三部曲：

  1. 确定递归函数的参数和返回值
  2. 确定终止条件
  3. 确定单层递归的逻辑
weixin_48668772
关注
专栏目录
Day26:竞技场第26天的资料库
04-05
"Day26:竞技场第26天的资料库"可能是指一个特定编程挑战或竞赛的第26天的主题，可能涉及到特定的技术领域或编程问题。然而，由于提供的信息有限，我们无法得知具体的技术细节。通常这类挑战会涵盖算法、数据结构、...
2021-2022计算机二级等级考试试题及答案No.17324.docx
10-29
2. 二叉树的第n层最多有2^(n-1)个节点，所以第5层最多有2^(5-1)=16个节点，答案是B。 3. 数据库系统中，除了层次模型和关系模型，还有网状模型（C）以及后来出现的对象-关系模型和NoSQL模型等。 4. 软件设计中的...
python刷题day2.rar
04-23
这个名为"python刷题day2.rar"的压缩包似乎是一个学习资源集合，针对Python编程的实战练习，特别是针对面试中常见的算法问题。从文件名来看，我们可以提炼出以下几个核心知识点： 1. **滑动窗口最大值**： 这个...
2021-2022计算机二级等级考试试题及答案No.19583.docx
10-31
18. 对二维数组进行行优先遍历，题目中的程序会打印第一列的元素，结果是1 5 9。 19. `mysqldump` 命令用于备份MySQL数据库的结构和数据，不是仅备份数据。 20. 关系数据库中，外键（Foreign Key）是指引用另一个...
noip2011赛前模拟day2
10-28
"Day2"可能指的是这次模拟训练的第二天，意味着存在一系列连续的训练日程，旨在逐步提升参赛者的技能。 【描述】提到"希望对大家拿一等奖有帮助"，这表明提供的资源是为那些期望在NOIP中获得优异成绩的选手准备的。...
leetcode209:长度最小的子数组
D2510466299的博客
10-12 560
我们需要从一个包含。
leetcode链表（四）-删除链表的倒数第N个节点
weixin_40198632的博客
10-11 372
给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。
LeetCode | 704.二分查找
编程菜鸟的学习记录
10-12 247
LeetCode | 704.二分查找
【从零开始的LeetCode-算法】3099. 哈沙德数
最新发布
qq_40878316的博客
10-15 125
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
力扣10.13
qq_40052678的博客
10-13 351
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
力扣 19. 删除链表的倒数第 N 个结点
J_pluto的博客
10-14 169
删除链表中的指定节点
【算法题】279. 完全平方数-力扣(LeetCode)
Janium的博客
10-10 638
1. **空间优化**：由于动态规划的状态转移方程只依赖于前一行的数据，可以将二维数组优化为一维数组。 2. **减少不必要的计算**：在构建完全平方数列表时，可以直接使用一个列表来存储这些数，而不需要每次计算平方。
Leetcode 415. Add Strings
小白菜又菜
10-13 234
【代码】Leetcode 415. Add Strings。
LeetCode组合总和
山雀的博客
10-09 853
LeetCode组合总和
力扣11-盛最多水的容器
qq_40926675的博客
10-09 646
给定一个长度为n的整数数组height。有n条垂线，第i条线的两个端点是(i, 0)和。找出其中的两条线，使得它们与x轴共同构成的容器可以容纳最多的水。返回容器可以储存的最大水量。你不能倾斜容器。
[LeetCode] 面试题01.02 判定是否互为字符重拍
weixin_65043441的博客
10-12 365
判定是否互为字符重排 如果s1和s2互为重排字符，那么s1和s2的长度一定是相等的。然后我们可以借助数组实现一个hash，判断s1的字符及数量是否和s2相同即可。，请编写一个程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。给定两个由小写字母组成的字符串。
代码训练营 day34|LeetCode 134，LeetCode 135，LeetCode 860，LeetCode 406
qq_44639909的博客
10-15 788
今天还是贪心算法的一系列题目，感觉今天的题目都有点难度。加油，坚持打卡的第34天。
【JavaScript】LeetCode：61-65
weixin_45980065的博客
10-12 1051
从根结点开始与单词的第一个字符进行匹配，一直匹配到前缀链上没有对应的字符，这时开始不断开辟新的结点，直到插入完单词的最后一个字符，并将最后一个结点isEnd = true，表示它是一个单词的末尾。从根结点开始一直向下匹配，如果前缀链上没有对应的字符就返回false，如果直到最后一个字符都匹配，则返回所匹配最后一个节点的isEnd。和查找类似，只是不需要判断最后一个字符结点的isEnd，因为既然能匹配到最后一个字符，就一定有单词以prefix为前缀。前缀匹配：判断Trie中是否有以prefix为前缀的单词。
【LeetCode】每日一题 2024_10_10 优质数对的总数 I（暴力/哈希）
Locky136的博客
10-10 511
【LeetCode】每日一题 2024_10_10 优质数对的总数 I（暴力/哈希）
严蔚敏教材第六章：树与二叉树解题指南
"严蔚敏教材的第六章主要讨论了树和二叉树的相关概念与操作，包括子孙关系判断、相似树的识别以及不同遍历方法的实现。" 在计算机科学中，树是一种非线性数据结构，广泛应用于各种领域，如文件系统、编译器设计、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值