目录
递归算出数的深度
- 树的深度:从根节点到最远叶子节点的节点数。
思路解析
1
/ \
2 3
/ \
4 5
- 当 root 是 4 时,它的左子树和右子树都为空(nil)。此时,maxDepth(root.Left) 和 maxDepth(root.Right) 都返回 0。所以,当前节点 4 的深度为 max(0, 0) + 1,即 1。
- 当 root 是 5 时,同样它的左子树和右子树都为空(nil),深度也是 1。
- 当 root 是 2 时,它的左子树的深度是 1(由 4 计算得到),右子树的深度是 1(由 5 计算得到)。所以,当前节点 2 的深度为 max(1, 1) + 1,即 2。
- 当 root 是 3 时,它的左子树和右子树都为空(nil),深度也是 1。
- 最后,当 root 是 1 时,它的左子树的深度是 2(由 2 计算得到),右子树的深度是 1(由 3 计算得到)。所以,当前节点 1 的深度为 max(2, 1) + 1,即 3。
- 因此,整棵树的最大深度为 3。
Go代码
func maxDepth(root *TreeNode) int {
if root == nil {
return 0
}
return max(maxDepth(root.Left), maxDepth(root.Right))+1
}
func max(num1 int, num2 int) int {
if num1 >= num2 {
return num1
}
return num2
}
题目:二叉树的最大深度
方法一:递归
复杂度:时间复杂度 O ( n ) O(n) O(n)、空间复杂度 O ( h e i g h t ) O(height) O(height)
- 空间复杂度 O ( h e i g h t ) O(height) O(height):其中 height 表示二叉树的高度。递归函数需要栈空间,而栈空间取决于递归的深度,因此空间复杂度等价于二叉树的高度。
Go代码
func maxDepth(root *TreeNode) int {
if root == nil {
return 0
}
return max(maxDepth(root.Left), maxDepth(root.Right))+1
}
func max(num1 int, num2 int) int {
if num1 >= num2 {
return num1
}
return num2
}
方法二:层序遍历
复杂度:时间复杂度 O ( n ) O(n) O(n)、空间复杂度 O ( n ) O(n) O(n)
- 空间复杂度 O ( n ) O(n) O(n):此方法空间的消耗取决于队列存储的元素数量,在最坏情况下会达到 O ( n ) O(n) O(n)
Go代码
func maxDepth(root *TreeNode) int {
if root == nil {
return 0
}
depth := 0
queue := []*TreeNode{root}
for len(queue) != 0 {
depth++
length := len(queue)
for i:=0;i<length;i++{
if queue[i].Left != nil {
queue = append(queue, queue[i].Left)
}
if queue[i].Right != nil {
queue = append(queue, queue[i].Right)
}
}
queue = queue[length:]
}
return depth
}
题目:二叉树的最小深度
方法一:递归
思路分析
如果按照最大深度的代码的话,如果根节点只有左子树或者右子树的话,那么最小值就恒定为0了。
所以把递归条件设置为只有非空子树才递归比较大小就好了。
Go代码
func minDepth(root *TreeNode) int {
if root == nil {
return 0
}
if root.Left == nil {
return minDepth(root.Right) + 1
} else if root.Right == nil {
return minDepth(root.Left) + 1
} else {
return min(minDepth(root.Left), minDepth(root.Right)) + 1
}
}
func min(num1 int, num2 int) int {
if num1 <= num2 {
return num1
}
return num2
}
方法二:层序遍历
思路分析
当处理每层节点时,如果取出节点的左右子节点都为nil,则代表该层就是树的最小深度。
Go代码
func minDepth(root *TreeNode) int {
if root == nil {
return 0
}
depth := 0
queue := []*TreeNode{root}
find := false
for len(queue) != 0 {
depth++
length := len(queue)
for i:=0;i<length;i++ {
if queue[i].Left != nil {
queue = append(queue, queue[i].Left)
}
if queue[i].Right != nil {
queue = append(queue, queue[i].Right)
}
if queue[i].Left == nil && queue[i].Right == nil {
find = true
break
}
}
if find {
break
}
queue = queue[length:]
}
return depth
}