给定一个二叉树
root
,返回其最大深度。二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。
示例 1:
输入:root = [3,9,20,null,null,15,7] 输出:3示例 2:
输入:root = [1,null,2] 输出:2提示:
- 树中节点的数量在
[0, 104]
区间内。-100 <= Node.val <= 100
时间复杂度: O(N)
每个结点只访问一次,因此时间复杂度为 O(N),其中 N 是结点数。
空间复杂度:O(N)
在最糟糕的情况下,树是完全不平衡的,例如每个结点只剩下左子结点,递归将会被调用 N 次(树的高度),因此保持调用栈的存储将是 O(N)。但在最好的情况下(树是完全平衡的),树的高度将是 log(N)。因此,在这种情况下的空间复杂度将是 O(log(N))。
思路:
参考 LeetCode题解
解法1 递归(dfs):
- 添加终结条件,空节点深度为0
- 左子树深度 +1
- 右子树深度 +1
- 返回左或右中的较大者
解法2 迭代(bfs):
- 每遍历一层,则计数器 +1 ,直到遍历完成,则可得到树的深度。
Go版本:
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
// 解法1 dfs(递归)
func maxDepth(root *TreeNode) int {
if root == nil {
return 0 // 节点不存在,返回 深度=0
}
l := maxDepth(root.Left) // 向左边递归得到的深度
r := maxDepth(root.Right) // 向右边递归得到的深度
return max(l, r) + 1 // 比较并返回最大深度
}
func max(a, b int) int {
if a > b {
return a
}
return b
}
// 解法2 bfs(迭代):利用队列"先进先出"的性质
func maxDepth(root *TreeNode) int {
if root == nil {
return 0
}
res := 0
queue := make([]*TreeNode, 0)
queue = append(queue, root)
for len(queue) > 0 {
// 保留上一层节点数,避免内存循环因为对queue进行append操作,导致n值变化
n := len(queue)
for i := 0; i < n; i++ {
root = queue[0] // get front node value
queue = queue[1:] // pop
if root.Left != nil {
queue = append(queue, root.Left)
}
if root.Right != nil {
queue = append(queue, root.Right)
}
}
res++
}
return res
}
C++版本:
int maxDepth(TreeNode* root) {
// 1.递归终结条件
if (root == NULL)
return 0;
// 2.处理当前层逻辑
int l = maxDepth(root->left) + 1; // 向左边递归得到的深度
int r = maxDepth(root->right) + 1; // 向右边递归得到的深度
// 3.下探到下一层
return l > r ? l : r; // 比较并返回最大深度
}
另外,这道题使用递归的解题方法步骤如下图(按这4步来熟悉递归的过程):
方法2 迭代(BFS,利用队列):
int maxDepth(TreeNode* root)
{
int sum = 0;
queue<TreeNode*> q;
q.push(root);
while (!q.empty())
{
for (int i = 0; i < q.size(); i++) // size:上一层节点个数
{
root = q.front();
//cout << root->data << endl;
q.pop();
if (root->left != NULL)
q.push(root->left);
if (root->right != NULL)
q.push(root->right);
}
sum++;
}
return sum;
}