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

已于 2023-02-17 22:41:43 修改
阅读量136 收藏
点赞数
文章标签： 算法 leetcode 数据结构
于 2023-02-16 21:09:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KINGjunT/article/details/129053996
版权

今天和明天要准备面试，暂时先停止两天，会在后续两天补上

104.二叉树的最大深度

题目链接

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数
说明: 叶子节点是指没有子节点的节点。
在这里插入图片描述
思路：明白什么是高度什么是深度
本题可以使用前序（中左右），也可以使用后序遍历（左右中），使用前序求的就是深度，使用后序求的是高度。

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

而根节点的高度就是二叉树的最大深度，所以本题中我们通过后序求的根节点高度来求的二叉树最大深度。
递归法：

  1. 确定函数返回值和参数
    参数就是传入树的根节点，返回就返回这棵树的深度，所以返回值为int类型。
int getdepth(TreeNode* node)
  1. 确定递归终止条件
    如果为空节点的话，就返回0，表示高度为0。
if (node == NULL) return 0;
  1. 确定单层递归的逻辑
    先求它的左子树的深度，再求右子树的深度，最后取左右深度最大的数值 再+1 （加1是因为算上当前中间节点）就是目前节点为根节点的树的深度。
int leftdepth = getdepth(node->left);       // 左
int rightdepth = getdepth(node->right);     // 右
int depth = 1 + max(leftdepth, rightdepth); // 中
return depth;

class Solution {
public:
    int getheight(TreeNode* node) {
        if (node == nullptr) return 0;
        int leftheight = getheight(node->left); // 左
        int rightHeight = getheight(node->right); // 右
        int height = 1 + max(leftheight, rightHeight);
        return height;
    }
    int maxDepth(TreeNode* root) {
        return getheight(root);
    }
};

总结：本题首先要明确什么是高度，什么是深度，对于不同的理解可以有不同的解法，所以一定要明白

简化写法

class Solution {
public:
    int getheight(TreeNode* node) {
        if (node == nullptr) return 0;
        return 1 + max(getheight(node->left), getheight(node->right));
    }
    
    int maxDepth(TreeNode* root) {
        return getheight(root);
    }
};

这种写法不容易理解，可以在二刷的时候来看，现在的能力不够，还需要努力。

思路2迭代法
这个写法在层序遍历的时候写过，只需要加一个深度变量来统计深度即可

class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != nullptr) {
            que.push(root);
        }
        int count = 0;
        while (!que.empty()) {
            int size = que.size();
            while (size--) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            count++;
        }
        return count;
    }
};

559.n叉树的最大深度

题目链接

给定一个 N 叉树，找到其最大深度。
最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。
在这里插入图片描述
思路1：迭代法

  1. 和遍历二叉树一样，不过在循环里面插入节点的时候，使用了auto child : node->children，可能以后遇到了会忘记，希望自己牢记
class Solution {
public:

    int maxDepth(Node* root) {
        if (root == nullptr) return 0;
        queue<Node*> que;
        que.push(root);
        int depth = 0;

        while (!que.empty()) {
            int size = que.size();
            
            while (size--) {
                Node* node = que.front();
                que.pop();
                for (auto child : node->children) {
                    que.push(child);
                }
            }
            depth++;
        }
        return depth;
    }
};

思路2： 递归

  1. 和二叉树的最大深度一样，这种递归不是很好理解，还需要加强练习。
class Solution {
public:

    int maxDepth(Node* root) {
        if (root == nullptr) 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.二叉树的最小深度

题目链接
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。

思路：

  1. 首先，还是要强调：本题依然是前序遍历和后序遍历都可以，前序求的是深度，后序求的是高度。

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

  2. 题目中说的是：最小深度是从根节点到最近叶子节点的最短路径上的节点数量。注意是叶子节点。
    什么是叶子节点，左右孩子都为空的节点才是叶子节点！

递归法
1/确定递归函数的参数和返回值
参数为要传入的二叉树根节点，返回的是int类型的深度。

int getDepth(TreeNode* node)

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

if (node == nullptr) return 0;

3、确定单层递归的逻辑
（牢记左右节点都为空才是叶子节点），所以代码如下

int leftDepth = getDepth(node->left);           // 左
int rightDepth = getDepth(node->right);         // 右
                                                // 中
// 当一个左子树为空，右不为空，这时并不是最低点
if (node->left == NULL && node->right != NULL) { 
    return 1 + rightDepth;
}   
// 当一个右子树为空，左不为空，这时并不是最低点
if (node->left != NULL && node->right == NULL) { 
    return 1 + leftDepth;
}
int result = 1 + min(leftDepth, rightDepth);
return result;

完整代码如下

class Solution {
public:
    int getDepth(TreeNode* node) {
        if (node == nullptr) return 0;

        int leftDepth = getDepth(node->left);
        int rightDepth = getDepth(node->right);

        if (node->left == nullptr && node->right != nullptr) {
            return 1 + rightDepth;
        }
        if (node->left != nullptr && node->right == nullptr) {
            return 1 + leftDepth;
        }

        int minL = 1 + min(leftDepth, rightDepth); //1是为了加上根节点
        return minL;
    }

    int minDepth(TreeNode* root) {
        return getDepth(root);
    }
};

精简代码：不容易理解，二刷的时候再看即可

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        if (root->left == NULL && root->right != NULL) {
            return 1 + minDepth(root->right);
        }
        if (root->left != NULL && root->right == NULL) {
            return 1 + minDepth(root->left);
        }
        return 1 + min(minDepth(root->left), minDepth(root->right));
    }
};

迭代法：
在遍历的过程中加上判断叶子条件的if语句，当节点的左右孩子都为空的时候，返回深度。

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == nullptr) return 0;
        queue<TreeNode*> que;
        que.push(root);
        int count = 0;

        while (!que.empty()) {
            int size = que.size();
            count++;
            while (size--) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left != nullptr) que.push(node->left);
                if (node->right != nullptr) que.push(node->right);
                if (node->left == nullptr && node->right == nullptr) {
                    return count;
                }
            }
        }
        return count;
    }
};

总结：对于这道题，最重要的一个条件就是 ：左右孩子都为空的节点才是叶子节点！
当知道这个条件以后，对于遍历来说就很容易了。

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

题目链接

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

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

思路1：常规迭代法

  1. 遍历整个二叉树，在弹出队列元素的时候计数，输出结果
class Solution {
public:
    int countNodes(TreeNode* root) {
        if (root == nullptr) return 0;
        queue<TreeNode*> que;
        que.push(root);
        int count = 0;

        while (!que.empty()) {
            int size = que.size();
            while (size--) {
                auto node = que.front();
                que.pop();
                count++;
                if (node->left) {
                    que.push(node->left);
                }
                
                if (node->right) {
                    que.push(node->right);
                }
            }
        }
        return count;
    }
};

总结1：虽然能AC，但是并不是本道题的主要完成的方法。接下来看递归法

思路2：完全二叉树递归法

完全二叉树只有两种情况，情况一：就是满二叉树，情况二：最后一层叶子节点没有满。
对于情况一，可以直接用 2^树深度 - 1 来计算，注意这里根节点深度为1。

  1. 分别向左遍历和向右遍历，因为是完全二叉树的缘故，只用遍历最外边即可。
  2. 判断左右相等的情况，当左右深度相同的情况，向他们的中间节点返回深度
    在这里插入图片描述

递归三部曲的第二部：确定终止条件如下

if (root == nullptr) return 0; 
// 开始根据左深度和右深度是否相同来判断该子树是不是满二叉树
TreeNode* left = root->left;
TreeNode* right = root->right;
int leftDepth = 0, rightDepth = 0; // 这里初始为0是有目的的，为了下面求指数方便
while (left) {  // 求左子树深度
    left = left->left;
    leftDepth++;
}
while (right) { // 求右子树深度
    right = right->right;
    rightDepth++;
}
if (leftDepth == rightDepth) {
    return (2 << leftDepth) - 1; // 注意(2<<1) 相当于2^2，返回满足满二叉树的子树节点数量
}

递归第三步：

int leftTreeNum = countNodes(root->left);       // 左
int rightTreeNum = countNodes(root->right);     // 右
int result = leftTreeNum + rightTreeNum + 1;    // 中
return result;

整体代码如下：

class Solution {
public:
    int countNodes(TreeNode* root) {
        if (root == nullptr) return 0;
        TreeNode* left = root->left, *right = root->right;
        int leftLenth = 0, rightLen = 0;

        while (left) {
            left = left->left;
            leftLenth++;
        }
        while (right) {
            right = right->right;
            rightLen++;
        }
        if (leftLenth == rightLen) {
            return (2<<leftLenth) - 1;
        }

        int leftTree = countNodes(root->left);
        int rightTree = countNodes(root->right);
        return leftTree + rightTree + 1;
    }
};

总结：还是不太喜欢递归法，在使用的过程中害怕写不好递归的逻辑，反而要多加练习才行，本题难度不大，重要的还是要学会利用完全二叉树和满二叉树的特性，这样解题思路更多。

RuojiFW
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
leetcode 104. 二叉树的最大深度（C++）
12-22
python版——>leetcode 104：二叉树的最大深度(python) 文章目录题目层次遍历法递归法 题目 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有...
leetcode-4.28[107. 二叉树的层次遍历 II、101. 对称二叉树、104. 二叉树的最大深度]（python解法）
01-20
题目1 原创文章 81获赞 40访问量 3万+ 关注 私信 展开阅读全文 作者：Leadingme
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
c语言编程题之树操作二叉树的最大深度.zip
04-02
本主题聚焦于如何计算二叉树的最大深度，这是一个经典的问题，通常在算法竞赛或面试中出现。 首先，我们需要理解什么是树的深度。在一棵二叉树中，根节点的深度为0。如果一个节点有非空子节点，那么这个节点的深度...
趣味算法------试用 6 和 9 组成的最大数字
markingyi的博客
08-26 553
给出一个数字，反转其中一位使数字最大化，递归求解。
递归、搜索与回溯算法
无聊_人的博客
08-29 2889
所谓的递归其实就是函数自己调用自己的情况。
7-7 数组中能被5整除的数的和
Virgo_616的博客
08-26 2660
在一维数组中有10个整数，求出其中能被5整除的所有数的和。
力扣1074.元素和为目标值的子矩阵数量
Pisasama的博客
08-27 476
【代码】力扣1074.元素和为目标值的子矩阵数量。
趣味算法------猴子吃桃(循环，递归双重解法)
markingyi的博客
08-26 452
猴子吃桃问题，已知结果求初始值，分别使用循环和递归两种方式解决。
精选算法编程题
A18937260063的博客
08-30 230
数组编程
Java算法之插入排序（Insertion Sort）
weixin_38959316的博客
08-29 182
插入排序是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。这个过程像打牌时整理手中的牌一样，逐步将数据排列成有序。插入排序虽然在实际应用中的效率不如一些更高级的排序算法，但它的原理简单，易于实现，且对于部分有序的数据集表现良好。
数据结构与算法——Java实现 2.衡量算法好坏的标准
m0_73983707的博客
08-27 446
为了对 f(n)进行化简，应当抓住主要矛盾，找到一个变化趋势与之相近的表示法。与时间复杂度类似，一般也使用大O表示法来衡量：一个算法执行随数据规模增大，而。假设算法要处理的数据规模是n，代码总的执行行数用函数 f(n)来表示。③ 不同底数的对数，渐进上界可以用一个对数函数 log n 表示。时间复杂度是用来衡量:一个算法的执行，随数据规模增大，而。② 多项式中数量规模更小(低次项)的表达式。① 表达式中相乘的常量，可以省略。④ 类似的，对数的常数次幂可省略。已知 f(n) ，求 g(n)
【CSP】坐标变换2(问题拆解,快速输入,知识补充)
最新发布
weixin_72391681的博客
08-30 1010
总结在这道题目中，我们通过旋转矩阵公式解决了二维平面上的坐标旋转问题，并且通过对浮点数的精度控制，满足了输出精度要求。我们还讨论了如何通过设定缓冲区和自定义输入函数优化大规模数据的输入输出效率。启发几何问题的推广：旋转矩阵的思路不仅适用于二维旋转，还可以推广到三维或更高维度的旋转问题，甚至可以应用于计算机图形学中的各种变换操作。精度控制的重要性：在涉及到浮点数运算的题目中，精度控制是至关重要的。了解并合理使用C++中的格式化输出可以有效避免因为精度丢失导致的错误。高效输入输出的技巧。
树上dp+分组背包类问题
2301_80475191的博客
08-29 1639
今天也是无意间看到了一个树上dp+分组背包类的问题，有些难度的，不好想的嘞，话不多说直接看题。
inflight 守恒算法负反馈解析
Netfilter
08-27 2794
特别在汇聚或骨干网络，就算 phase 全部打散，至多有 6 个完全独立的 phase slot，而在叠加 phase，同时 probe 将导致 buffer 占量增加，这问题类似 vegas 分析中，如果每条流保持 α < diff < β，n 条流的 diff 下界就是 n * α，当 n 很大时，排队时间将不可避免增加。可见，除了保持 buffer 占量在多流场景下算法可扩展，我引入负反馈的另一个意义在于，让收敛更快，设 x > y，p1 = x。浙江温州皮鞋湿，下雨进水不会胖。
基于用户的协同过滤以及ALS的混合召回算法
zhangdonghuirjdd的博客
08-28 1262
基于用户的协同过滤是一种经典的推荐算法，它通过寻找具有相似兴趣的用户来推荐物品，它关注的是用户之间的相似性而非物品之间的相似性。然而，在大规模数据集上，这种方法可能会因为计算用户相似度矩阵所需的大量计算资源而变得不太实用。基于用户之间的相似度来进行推荐。在基于用户的协同过滤中，系统寻找与目标用户兴趣相似的其他用户，然后推荐这些相似用户喜欢的物品给目标用户。ALS 的优点（如处理稀疏数据的能力）来改进基于用户的协同过滤。因为不同用户直接的评分范围差异比较大 使用余弦相似度来计算。
推荐召回中ALS(交替最小二乘法)算法验证
zhangdonghuirjdd的博客
08-26 655
bm25_weight函数期望输入是一个物品-用户评分矩阵，即转置后的user_item_matrix.T。在推荐系统中，它可以提高推荐的质量。这里两次使用转置操作的原因在于bm25_weight函数的输入期望是物品-用户评分矩阵，而不是用户-物品评分矩阵。ALS是一种广泛应用于协同过滤推荐系统的方法，主要用于解决用户-物品评分矩阵中的缺失值问题，从而生成用户对未评分物品的预测评分或推荐。Format）的稀疏矩阵。原始的user_item_matrix是一个用户-物品评分矩阵，其中行代表用户，列代表物品。
每天学习一个基础算法之二分查找
gybhh的博客
08-30 549
前一篇博客我们已经介绍学习了顺序查找法，它在对有序数据查找时效率较低，而当我们要对有序数据进行查找时就要用到二分查找法了，所以今天我们要学习的就是二分查找法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值