104.二叉树的最大深度
104. 二叉树的最大深度 - 力扣（LeetCode）
https://leetcode.cn/problems/maximum-depth-of-binary-tree/description/
什么是二叉树的深度和高度？
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。最大深度==二叉树的层数==根节点的深度==根节点的高度==第二层节点的最大高度+1。
二叉树某个节点的深度：指从根节点到该节点的最长简单路径边的条数。
二叉树某个节点的高度：指从该节点到叶子节点的最长简单路径边的条数。
题目描述：
给定一个二叉树 root ，返回其最大深度。
二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。
示例 1：
输入：root = [3,9,20,null,null,15,7] 输出：3
示例 2：
输入：root = [1,null,2] 输出：2
思路分析：
本题可以使用前序（中左右），也可以使用后序遍历（左右中），使用前序求的就是深度，使用后序求的是高度。
后序递归解法
下面先尝试使用后序递归实现最大深度的求法。
递归第一步：确认递归函数的参数和返回值。题目已经给出，参数为二叉树的根节点指针，返回值为最大深度，所以返回值类型为int。
int maxDepth(TreeNode* root){}递归第二步：确认终止条件。那就是如果传入的root为nullptr，则返回0。即递归结束的条件为空树，即没有子树可以继续下一层的递归。
if(root == nullptr) return 0;递归第三步：确认单层递归逻辑。按照该思路，在单层递归时应该分别统计当前root（可以时根节点，也可以是子树的根节点）的左右子树的最大高度，然后取两者中的最大值。则当前root的深度为两者中的最大值+1，即：
//左子树的高度
int left = maxDepth(root->left);
//右子树的高度
int right = maxDepth(root->right);
int depth = max(left, right) + 1; //中
return depth;后序整体代码如下：
/**
* 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 maxDepth(TreeNode* root) {
if(root == nullptr) return 0;
//左子树的高度
int left = maxDepth(root->left); //左
//右子树的高度
int right = maxDepth(root->right); //右
int depth = max(left, right) + 1; //中
return depth;
}
};层序遍历解法
由于二叉树的最大深度就是二叉树的层数，所以使用前文所讲的层序遍历来计算深度（层数）。具体代码如下：
class Solution {
public:
//采用层序遍历
int maxDepth(TreeNode* root) {
if(root == nullptr) return 0;
queue<TreeNode*> que;
que.push(root);
int depth = 0;
while(!que.empty())
{
int size= que.size();
//当前层存在，深度++
++depth;
//遍历当前层各节点
for(int i=0; i<size; i++)
{
//去每一层的各节点必须放在for循环里
TreeNode *node = que.front();
que.pop();
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}
}
return depth;
}
};前序递归解法
最后介绍一下前序解法，我理解来比较困难，大家可以看一下：
class solution {
public:
int result;
void getdepth(TreeNode* node, int depth) {
result = depth > result ? depth : result; // 中
if (node->left == NULL && node->right == NULL) return ;
if (node->left) { // 左
depth++; // 深度+1
getdepth(node->left, depth);
depth--; // 回溯，深度-1
}
if (node->right) { // 右
depth++; // 深度+1
getdepth(node->right, depth);
depth--; // 回溯，深度-1
}
return ;
}
int maxDepth(TreeNode* root) {
result = 0;
if (root == NULL) return result;
getdepth(root, 1);
return result;
}
};559.N叉树的最大深度
559. N 叉树的最大深度 - 力扣（LeetCode）https://leetcode.cn/problems/maximum-depth-of-n-ary-tree/description/
题目描述：
给定一个 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
有了前面二叉树的解法，下面直接给出后序递归解法：
后序递归解法
/*
// Definition for a Node.
class Node {
public:
int val;
vector<Node*> children;
Node() {}
Node(int _val) {
val = _val;
}
Node(int _val, vector<Node*> _children) {
val = _val;
children = _children;
}
};
*/
class Solution {
public:
int maxDepth(Node* root) {
if(root == nullptr) return 0;
int depth = 0;
for(int i = 0; i < root->children.size(); ++i)
{
int children_i_depth = maxDepth(root->children[i]);
depth = max(children_i_depth, depth) ; //注意，这里只找子树的最大高度
}
return depth+1; //深度是在子树最大高度的基础上加1
}
};层序遍历解法：
class Solution {
public:
int maxDepth(Node* root) {
if(root == nullptr) return 0;
int depth = 0;
queue<Node *> que;
que.push(root);
while(!que.empty())
{
int size = que.size();
++depth;
for(int i = 0; i<size; i++)
{
Node * node = que.front();
que.pop();
for(int j = 0;j < node->children.size();j++)
{
if(node->children[j] != nullptr)
que.push(node->children[j]);
}
}
}
return depth;
}
};
