今日刷题重点—二叉树的深度
104. 二叉树的最大深度
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3
/ \
9 20
/ \
15 7
返回它的最大深度 3
方法一:递归(后序)
递归三要素:
- 参数和返回值:参数就是树的根节点,返回值:树的深度
- 结束条件:如果为空节点NULL，就返回0，表示高度为0
- 单层递归逻辑:先求左子树的深度,再求右子树的深度,最后取左右深度的最大值,再+1(因为要算上当前的节点),返回的就是以目前节点为根节点的树的深度.
参考代码1
int maxDepth(TreeNode* root) {//参数为要判断层数的节点
if(root==NULL) { //结束条件
return 0;
}
int leftDepth = maxDepth(root->left);//每次继续递归计算左子树的深度
int rightDepth = maxDepth(root->right);//计算右子树的深度
int depth = 1 + max(leftDepth,rightDepth);//寻找最大的然后加上当前层便是到当前节点的深度.
return depth;//返回给上一层.
}
方法二:递归(先序)
使用一个变量记录每一层递归过程中树的最大深度,最后进行返回.
递归三要素:
- 参数和返回值:参数就是树的根节点 root 和 从根节点到当前节点的深度depth.
- 结束条件:当遇到叶子节点时就不需要往下递归了.
- 单层递归逻辑: 如果根节点的左子树不为空,则继续进行递归,同时传入的depth+1 . 左子树递归完毕后,进行右子树的递归…
参考代码2
//递归法:先序
int result;
void getDepth(TreeNode* node,int depth){//depth:表示到root为止,树的深度.
result = depth>result ? depth : result; //进来该函数之后先更新result;
if(node->left==NULL&&node->right==NULL){//判断左右节点是否为空
return;
}
if(node->left){
depth++;
getDepth(node->left,depth);
depth--;//进行回溯 用于下面右子树的递归判断.
}
if(node->right){
// depth++;
// getDepth(node->right,depth);
// depth--;
getDepth(node->right,depth+1);
}
return;
}
int maxDepth(TreeNode* root) {
result = 0;
if(root==NULL) {
return 0;
}
getDepth(root,1);
return result;
}
方法三—迭代法(层次遍历)
采用队列一层层的进行遍历,每次depth++.
这种方法写起来和理解起来最佳
参考代码3
//方法三:层次遍历(最好理解.)
int maxDepth(TreeNode* root) {
if(root==NULL){
return 0;
}
queue<TreeNode*> Q;
Q.push(root);
int depth = 0;
while(!Q.empty()){
int size = Q.size();
for(int i = 0;i < size;i++){
TreeNode* node = Q.front();
Q.pop();
if(node->left){
Q.push(node->left);
}
if(node->right){
Q.push(node->right);
}
}
depth++;//每遍历一层depth++
}
return depth;
}
559. N 叉树的最大深度
给定一个 N 叉树，找到其最大深度。
最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。
示例 1：
输入：root = [1,null,3,2,4,null,5,6]
输出：3
示例 2：
输入：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
思路分析:
N叉树只是 父节点上的子节点有多个,其他的和二叉树处理思路相同.
参考代码1—递归(后序)
//递归 后序..
int maxDepth(Node* root) {
if(root==NULL) {
return 0;
}
int depth,maxdepth = 0;
for(int i = 0; i < root->children.size(); i++) {
depth = maxDepth(root->children[i]);//获取到当前子节点的深度.
maxdepth = max(depth,maxdepth);//进行更新.
}
return maxdepth+1;//返回给上一层 到当前节点的深度.
}
参考代码2—递归(先序)
//递归,先序.
int result;
void getDepth(Node* node,int depth) {
result = depth > result ? depth : result;
for(int i = 0; i < node->children.size(); i++) {
if(node->children[i]) {
getDepth(node->children[i],depth+1);
}
}
return;
}
int maxDepth(Node* root) {
result = 0;
if(root==NULL) {
return 0;
}
getDepth(root,1);
return result;
}
参考代码3—迭代(层次遍历)
//迭代:层次遍历
int maxDepth(Node* root) {
if(root==NULL){
return 0;
}
queue<Node*> Q;
Q.push(root);
int depth = 0;
while(!Q.empty()){
int size = Q.size();
for(int i = 0;i < size;i++){
Node* node = Q.front();
Q.pop();
for(int j = 0;j < node->children.size();j++){
if(node->children[j]){
Q.push(node->children[j]);
}
}
}
depth++;
}
return depth;
}
111.二叉树的最小深度
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。
示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：2
示例 2：
输入：root = [2,null,3,null,4,null,5,null,6]
输出：5
方法一—递归(后序)
求最小深度时,因为是遍历到叶子节点才算一个深度.我们不可以直接在最大深度的算法上仅仅把返回值从max改成min就OK了.
如果那样的话,会出现如下: 算法求出的最小深度是1,但实际上是3
所以我们在处理时要注意节点左子树和右子树,一个为空一个不为空的特殊情况.
- 当左子树为空右子树不为空时,返回的应该是右子树深度+1;
- 当右子树为空左子树不为空时,返回的应该是左子树深度+1;
- 当左右子树都不为空时,返回的是两棵树的最小深度+1;
参考代码1
//递归
int minDepth(TreeNode* root) {
if(root==NULL) {
return 0;
}
int leftDepth = minDepth(root->left);
int rightDepth = minDepth(root->right);
if(root->left==NULL&&root->right) { //当左子树为空,右子树不为空,则深度= 右子树深度+1
return rightDepth+1;
}
if(root->right==NULL&&root->left) { //当左子树不为空,右子树为空,则深度= 左子树深度+1
return leftDepth+1;
}
return 1+min(leftDepth,rightDepth);//都不为空,则取最小的那个.
}
方法二—迭代法(层次遍历)
一遇到叶子节点就返回深度.
参考代码2
//层次遍历
int minDepth(TreeNode* root) {
if(root==NULL){
return 0;
}
queue<TreeNode*> Q;
Q.push(root);
int depth = 0;
while(!Q.empty()){
int size = Q.size();
for(int i = 0;i < size;i++){
TreeNode* node = Q.front();
Q.pop();
if(node->left){
Q.push(node->left);
}
if(node->right){
Q.push(node->right);
}
if(!node->left&&!node->right){
return depth+1;//带上当前层..
}
}
depth++;
}
return depth;
}
