[Go版]算法通关村第六关白银——递归算出树的深度

递归算出数的深度

• 树的深度：从根节点到最远叶子节点的节点数。

思路解析

    1
   / \
  2   3
 / \
4   5

1. 当 root 是 4 时，它的左子树和右子树都为空（nil）。此时，maxDepth(root.Left) 和 maxDepth(root.Right) 都返回 0。所以，当前节点 4 的深度为 max(0, 0) + 1，即 1。
2. 当 root 是 5 时，同样它的左子树和右子树都为空（nil），深度也是 1。
3. 当 root 是 2 时，它的左子树的深度是 1（由 4 计算得到），右子树的深度是 1（由 5 计算得到）。所以，当前节点 2 的深度为 max(1, 1) + 1，即 2。
4. 当 root 是 3 时，它的左子树和右子树都为空（nil），深度也是 1。
5. 最后，当 root 是 1 时，它的左子树的深度是 2（由 2 计算得到），右子树的深度是 1（由 3 计算得到）。所以，当前节点 1 的深度为 max(2, 1) + 1，即 3。
6. 因此，整棵树的最大深度为 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
}

题目：二叉树的最大深度

104. 二叉树的最大深度

方法一：递归

复杂度：时间复杂度$O(n)$、空间复杂度$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)$

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
}

题目：二叉树的最小深度

111. 二叉树的最小深度

方法一：递归

思路分析

如果按照最大深度的代码的话，如果根节点只有左子树或者右子树的话，那么最小值就恒定为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
}