一、104.二叉树的最大深度
题目链接/文章讲解/视频讲解： https://programmercarl.com/0104.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%A4%A7%E6%B7%B1%E5%BA%A6.html状态：已解决
1.思路
需要先明确一些概念。
- 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
- 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）
使用前序遍历求的就是深度（从根节点开始计数，即从前往后计数），使用后序求的是高度（从叶子节点的下一节点计数，即从后往前计数）。
（1）迭代
这道题做法很多，我的第一反应就是迭代，然后用层次遍历法秒了。对于层次遍历就是一个很简单的模板题，将每层的节点出栈后，将它们的左右子节点（即下一层的所有节点）入栈，重复这个过程，直到没有下一层节点位置，而该过程的重复执行数就是数的最大深度。除此之外，还需要一个size变量来记录新的一层的节点个数，以确定下次循环的终止。
（2）递归
对于递归法，我先按自己的想法随便乱写的，整理出来发现应该是后序遍历的顺序。能用后序遍历的根本依据是：根节点的高度，等于叶子节点的最大深度。因此可以用后序遍历来做，也就是先分别遍历左右两棵树，然后得出两个子树的高度，最后在中间节点处对比两个节点的高度，取二者中的最大值，并且再将该高度+1（加上自己这层的度数，即将子树的最大高度加上自己这层所占的一个深度，才为自己的高度，然后回溯给上一层节点，让上一层节点做类似的操作）。
不能用中序遍历，这个也很好理解，因为中序是遍历完左子树就可以在中间节点整理信息了，而此时右子树还没有遍历呢。
2.代码实现
（1）迭代：
class Solution {
public:
int maxDepth(TreeNode* root) {
int depth = 0;
queue<TreeNode*> q;
if(root == NULL) return depth;
q.push(root);
while(!q.empty()){
int size = q.size();
while(size--){
TreeNode * node = q.front();
q.pop();
if(node->left) q.push(node->left);
if(node->right) q.push(node->right);
}
depth++;
}
return depth;
}
};（2）递归
还可以再精简，但是不利于理解。
class Solution {
public:
int depth(TreeNode* node){
if(node == NULL) return 0;//叶子节点的下一个节点，不在树中，相当于是一个水平线，高度为0
int leftDepth = depth(node->left);//求左子树高度
int rightDepth = depth(node->right);//求右子树高度
return max(leftDepth,rightDepth)+1;//中间节点进行处理，对比哪个子树更深
}
int maxDepth(TreeNode* root) {
return depth(root);
}
};二、111.二叉树的最小深度
题目链接/文章讲解/视频讲解： https://programmercarl.com/0111.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%B0%8F%E6%B7%B1%E5%BA%A6.html状态：已解决
1.思路
（1）递归
这道题做之前就已经看到了提示，说不能用上面的那道题的逻辑来做了，于是我试着做了一下，发现确实不行。具体原因是：题目中的不是一颗完全二叉树，因此可能有的节点只有一个子树，而如果在上一道题后序遍历的代码基础上修改成求两颗子树高度的最小值，那么对于这种单节点，最小高度永远取没有子树的那边，导致为1，根本原因是还没到叶子节点，就直接取了另一侧空树的高度，空树高度肯定最小，因此这个结果在选择时被保留下来，传给上面，而在求最大值时单节点的高度会被筛掉，故上道题并不影响。
因此，需要对上题代码做修改，增加判断条件，确认为叶子节点才可以保留高度。
（2）迭代
由于迭代是从上往下，因此此题依旧适用。
2.代码实现
（1）递归
class Solution {
public:
int depth(TreeNode* node){
if(node == NULL) return 0;//叶子节点的下一个节点，不在树中，相当于是一个水平线，高度为0
int leftDepth = depth(node->left);//求左子树高度
int rightDepth = depth(node->right);//求右子树高度
if(node->left != NULL && node->right == NULL) return leftDepth+1;//没有右子树
if(node->left == NULL && node->right != NULL) return rightDepth+1;//没有左子树
return min(leftDepth,rightDepth)+1;//中间节点进行处理，对比哪个子树更深
}
int minDepth(TreeNode* root) {
return depth(root);
}
};（2）迭代
class Solution {
public:
int minDepth(TreeNode* root) {
int depth = 0;
queue<TreeNode*> q;
if(root == NULL) return depth;
q.push(root);
while(!q.empty()){
int size = q.size();
depth++;
while(size--){
TreeNode * node = q.front();
q.pop();
if(node->left == NULL && node->right == NULL) return depth;
if(node->left) q.push(node->left);
if(node->right) q.push(node->right);
}
}
return depth;
}
};三、 222.完全二叉树的节点个数
题目链接/文章讲解/视频讲解： https://programmercarl.com/0222.%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E8%8A%82%E7%82%B9%E4%B8%AA%E6%95%B0.html状态：已解决
1.思路
这个题前面的迭代和层次都可以做，但是这样做就偏离了这题原本想考的地方——即对完全二叉树的性质掌握。
有一个公式就是对于满二叉树，假设高度为n，那么节点数量为2^(n+1)-1（n从0开始），具体推导在我的上篇博客中。
因此，此题除了常规后序遍历统计左右子树节点数在中间节点汇总的常规方法外，还有一个走捷径的方法，也就是先判断子树是否为满二叉树，是的话直接用高度计算节点总数的公式秒了该节点的子树节点总数，如果不是的话，再用常规方法求节点总数。
那么如何去判断一个左子树或者右子树是不是满二叉树呢？在完全二叉树中，如果递归向左遍历的深度等于递归向右遍历的深度，那说明就是满二叉树。如图：
在完全二叉树中，如果递归向左遍历的深度不等于递归向右遍历的深度，则说明不是满二叉树，如图：
2.代码实现
（1）完全二叉树特性实现
也就是说，每次遍历子树时，有两条道路可以走，一种是直接走小路（公式计算，不用遍历子树中间结点），一种是走常规大路（后序遍历所有节点），但走小路有门槛，要确定为满二叉树才可以走这条路，走不了就只能走大路。
/**
* 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 getNums(TreeNode* node){
int leftDepth = 0;
int rightDepth = 0;
if(node == NULL) return 0;
//走捷径
TreeNode* left = node->left;
TreeNode* right = node->right;
while(left){
left = left->left;
leftDepth++;
}//左遍历深度
while(right){
right = right->right;
rightDepth++;
}//右遍历深度
if(leftDepth == rightDepth){//判断可不可以走捷径，可以走就直接用公式计算
return (2 << leftDepth)-1;
}
//不能走捷径就走常规道路
int leftNum = getNums(node->left); // 左
int rightNum = getNums(node->right); // 右
int treeNum = leftNum + rightNum + 1; // 中
return treeNum;
}
int countNodes(TreeNode* root) {
return getNums(root);
}
};（2）单纯后序遍历实现（大路）
class Solution {
private:
int getNodesNum(TreeNode* cur) {
if (cur == NULL) return 0;
int leftNum = getNodesNum(cur->left); // 左
int rightNum = getNodesNum(cur->right); // 右
int treeNum = leftNum + rightNum + 1; // 中
return treeNum;
}
public:
int countNodes(TreeNode* root) {
return getNodesNum(root);
}
};（3）迭代
class Solution {
public:
int countNodes(TreeNode* root) {
queue<TreeNode*> que;
if (root != NULL) que.push(root);
int result = 0;
while (!que.empty()) {
int size = que.size();
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
result++; // 记录节点数量
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return result;
}
};
137
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
