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;
}
}