104.二叉树的最大深度
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例： 给定二叉树 [3,9,20,null,null,15,7]，返回它的最大深度 3 。
看完本篇可以一起做了如下两道题目：
思路：本题要搞懂：什么是深度，什么是高度，如何求深度，如何求高度，这里有关系到二叉树的遍历方式。
递归法
本题可以使用前序（中左右），也可以使用后序遍历（左右中），使用前序求的就是深度，使用后序求的是高度。
- 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
- 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）
而根节点的高度就是二叉树的最大深度，所以本题中我们通过后序求的根节点高度来求的二叉树最大深度。 这一点其实是很多同学没有想清楚的，很多题解同样没有讲清楚。
我先用后序遍历（左右中）来计算树的高度。
- 确定递归函数的参数和返回值：参数就是传入树的根节点，返回就返回这棵树的深度，所以返回值为int类型。
- 确定终止条件：如果为空节点的话，就返回0，表示高度为0。
- 确定单层递归的逻辑：先求它的左子树的深度，再求右子树的深度，最后取左右深度最大的数值 再+1 （加1是因为算上当前中间节点）就是目前节点为根节点的树的深度。
精简之后的代码根本看不出是哪种遍历方式，也看不出递归三部曲的步骤，所以如果对二叉树的操作还不熟练，尽量不要直接照着精简代码来学。
//精简之后的代码根本看不出是哪种遍历方式，也看不出递归三部曲的步骤
return Math.max(maxDepth(root.left),maxDepth(root.right)) + 1;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; //中
}
}class Solution {
/**
* 递归法(求深度法)---前序遍历（中 左 右）
*/
int maxnum = 0; //定义了一个整型变量 maxnum，用于存储树的最大深度。
//定义了一个公有方法maxDepth，接受一个TreeNode类型的参数root，
//表示树的根节点。返回树的最大深度。
public int maxDepth(TreeNode root) {
ans(root,0); // 调用ans方法，传入根节点root和深度初始值0。
return maxnum;
}
//递归求解最大深度
//定义了一个递归方法 ans，接受一个 TreeNode 类型的参数 tr 表示当前节点，一个整型参数 tmp 表示当前节点的深度。
void ans(TreeNode tr,int tmp){
//如果当前节点为空，说明已经到达叶子节点的下一层，直接返回。
if(tr==null) return;
tmp++; //深度加 1，表示当前节点的深度增加了
maxnum = maxnum<tmp ? tmp : maxnum; // 更新maxnum变量，取当前节点深度和 maxnum 中较大的值作为新的最大深度。 （中）
ans(tr.left,tmp); //递归地对当前节点的左子树进行深度遍历。 （左）
ans(tr.right,tmp); //递归地对当前节点的右子树进行深度遍历。 （右）
tmp--; //回溯，当前节点的深度减 1，为了保持递归调用时深度的准确性。
}
}补充说明：
tmp--；是对深度变量进行递减操作，它的作用是在回溯时将当前节点的深度恢复到上一层的深度。在深度优先搜索的递归过程中，当访问完当前节点的左子树和右子树后，需要返回到上一层节点进行下一步操作。因为递归调用是通过栈来实现的，当从一个节点递归到其子节点时，会将当前节点的状态保存在栈中，等到递归返回时再从栈中弹出状态。而
tmp--就是在返回到上一层节点时，将深度减 1，恢复到上一层的深度状态。这样做的目的是保持递归调用的正确性，确保每个节点在递归过程中深度值的准确性，以便正确地计算树的最大深度。
559.n叉树的最大深度
给定一个 n 叉树，找到其最大深度。
最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
例如，给定一个 3叉树 : 我们应返回其最大深度，3。
思路：依然可以提供递归法和迭代法，来解决这个问题，思路是和二叉树思路一样的，直接给出代码如下：
class Solution {
//递归法
public int maxDepth(Node root) {
if(root == null) return 0;
int depth = 0;
//如果当前节点有子节点（即不是叶子节点），则执行以下操作：
if(root.children != null){
//遍历当前节点的每一个子节点，用变量 child 表示。
for(Node child : root.children){//增强for循环
//递归地计算每个子节点的深度，并将其与当前节点的深度depth进行比较，取其中较大的值作为当前节点的深度。
depth = Math.max(depth,maxDepth(child));
}
}
return depth + 1; //返回当前节点的深度加 1，表示当前节点所在的层级。
}
} 补充：java中N叉树的定义（定义了一个名为
Node的类，用于表示多叉树的节点。）class Node { public int val; //定义了一个公有的整型变量 val，用于存储节点的值。 //定义了一个公有的List 类型的变量children，用于存储节点的子节点列表。 //因为多叉树的节点可以有多个子节点，所以使用了List 类型来存储子节点。 public List<Node> children; public Node() {} //默认构造函数，没有参数，用于创建一个空的节点对象。 public Node(int _val) { //构造函数，接受一个整型参数 _val，用于创建一个具有给定值的节点对象。 val = _val; } //构造函数，接受一个整型参数 _val 和一个 List<Node> 类型的参数 _children， //用于创建一个具有给定值和子节点列表的节点对象。 public Node(int _val, List<Node> _children) { val = _val; children = _children; } }N叉树前、后序遍历的递归实现:
//前序 public List<Integer> preorder(Node root) { List<Integer> res = new ArrayList<>(); preOrderNT(root,res); return res; } private void preOrderNT(Node node, List<Integer> res) { if (node == null){ return; } res.add(node.val); if (node.children.size() >0){ for (Node _node:node.children) { preOrderNT(_node,res); } } } //后序 public List<Integer> postorder(Node root) { List<Integer> res = new ArrayList<>(); postOrderNT(root,res); return res; } private void postOrderNT(Node node, List<Integer> res) { if (node == null){ return; } if (node.children != null && node.children.size() > 0){ for (Node _node:node.children) { postOrderNT(_node,res); } } res.add(node.val); }
111.二叉树的最小深度
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明: 叶子节点是指没有子节点的节点。
示例:给定二叉树 [3,9,20,null,null,15,7], 返回它的最小深度 2.
思路：
看完了这篇104.二叉树的最大深度 (opens new window)，再来看看如何求最小深度。
直觉上好像和求最大深度差不多，其实还是差不少的。
本题依然是前序遍历和后序遍历都可以，前序求的是深度，后序求的是高度。
- 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
- 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数后者节点数（取决于高度从0开始还是从1开始）
那么使用后序遍历，其实求的是根节点到叶子节点的最小距离，就是求高度的过程，不过这个最小距离 也同样是最小深度。
以下讲解中遍历顺序上依然采用后序遍历（因为要比较递归返回之后的结果，本文我也给出前序遍历的写法）。
本题还有一个误区，在处理节点过程中，最大深度很容易理解，最小深度就不那么好理解，如图：
☆这里有个陷阱！这就需要重新审题了，题目中说的是：最小深度是从根节点到最近叶子节点的最短路径上的节点数量。注意是叶子节点！！！！
什么是叶子节点，左右孩子都为空的节点才是叶子节点！！！
递归法：
- 确定单层递归的逻辑
这块和求最大深度可就不一样了，一些同学可能会写如下代码：这就犯了如上错误！
int leftDepth = getDepth(node->left);
int rightDepth = getDepth(node->right);
int result = 1 + min(leftDepth, rightDepth);
return result;如果这么求的话，没有左孩子的分支会算为最短深度。(这样不正确)
---所以，如果左子树为空，右子树不为空，说明最小深度是 1 + 右子树的深度。
---反之，右子树为空，左子树不为空，最小深度是 1 + 左子树的深度。 最后如果左右子树都不为空，返回左右子树深度最小值 + 1 。
遍历的顺序为后序（左右中），可以看出：求二叉树的最小深度和求二叉树的最大深度的差别主要在于处理 左右孩子不为空的逻辑。
（精简之后的代码根本看不出是哪种遍历方式，所以依然还要强调一波：如果对二叉树的操作还不熟练，尽量不要直接照着精简代码来学。）
class Solution {
/**
* 递归法，相比求MaxDepth要复杂点
* 因为最小深度是从根节点到最近**叶子节点**的最短路径上的节点数量
*/
public int minDepth(TreeNode root) {
if(root == null) return 0;
int leftDepth = minDepth(root.left);
int rightDepth = minDepth(root.right);
if(root.left == null){
return rightDepth + 1;
}
if(root.right == null){
return leftDepth + 1;
}
//左右节点都不为空，返回最小的+1
return Math.min(leftDepth,rightDepth) + 1 ;
}
}222.完全二叉树的节点个数
给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。
完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含
~ 个节点。
思路：本篇给出按照普通二叉树的求法以及利用完全二叉树性质的求法。
普通二叉树
首先按照普通二叉树的逻辑来求。这道题目的递归法和求二叉树的深度写法类似， 而迭代法，二叉树：层序遍历登场！ (opens new window)遍历模板稍稍修改一下，记录遍历的节点数量就可以了。
递归遍历的顺序依然是后序（左右中）。
递归法
3.确定单层递归的逻辑：先求它的左子树的节点数量，再求右子树的节点数量，最后取总和再加一 （加1是因为算上当前中间节点）就是目前节点为根节点的节点数量。
int leftNum = getNodesNum(cur->left); // 左
int rightNum = getNodesNum(cur->right); // 右
int treeNum = leftNum + rightNum + 1; // 中
return treeNum;整体C++代码如下：
时间复杂度：O(n)； 空间复杂度：O(log n)，算上了递归系统栈占用的空间
网上基本都是这个精简的代码版本，其实不建议大家照着这个来写，代码确实精简，但隐藏了一些内容，连遍历的顺序都看不出来，所以初学者建议学习版本一的代码，稳稳的打基础。
java语言版本：
class Solution {
public int countNodes(TreeNode root) {
//通用递归解法
return getNodesNum(root);
}
private int getNodesNum(TreeNode root){
if(root == null) return 0;
int leftNum = getNodesNum(root.left);
int rightNum = getNodesNum(root.right);
int treeNum = leftNum + rightNum + 1;
return treeNum;
}
}精简版本：
class Solution { // 通用递归解法 public int countNodes(TreeNode root) { if(root == null) { return 0; } return countNodes(root.left) + countNodes(root.right) + 1; } }
class Solution {
/**
* 针对完全二叉树的解法
*
* 满二叉树的结点数为：2^depth - 1
*/
public int countNodes(TreeNode root) {
if (root == null) return 0;
TreeNode left = root.left;
TreeNode right = root.right;
int leftDepth = 0, rightDepth = 0; // 这里初始为0是有目的的，为了下面求指数方便
while (left != null) { // 求左子树深度
left = left.left;
leftDepth++;
}
while (right != null) { // 求右子树深度
right = right.right;
rightDepth++;
}
if (leftDepth == rightDepth) {
return (2 << leftDepth) - 1; // 注意(2<<1) 相当于2^2，所以leftDepth初始为0
}
return countNodes(root.left) + countNodes(root.right) + 1;
}
}
1010
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
