8-树-二叉树的最大深度

这是树的第8篇算法，力扣链接。

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：3

这道题还是可以用层级遍历来解，每一层count++即可。

func maxDepth(root *TreeNode) int {
	count := 0
	if root == nil {
		return count
	}
	queue := []*TreeNode{root}
	for len(queue) > 0 {
		count++
		newQueue := []*TreeNode{}
		for _, node := range queue {
			if node.Left != nil {
				newQueue = append(newQueue, node.Left)
			}
			if node.Right != nil {
				newQueue = append(newQueue, node.Right)
			}
		}
		queue = newQueue
	}
	return count
}

当然，也可以深度优先遍历，递归的方式：

func maxDepth(root *TreeNode) int {
	if root == nil {
		return 0
	}
	left, right := maxDepth(root.Left), maxDepth(root.Right)
	if left > right {
		return left + 1
	} else {
		return right + 1
	}
}

迭代的方法也能做，不过要构建新对象记录深度。

func maxDepth(root *TreeNode) int {
	if root == nil {
		return 0
	}

	// 定义一个栈，用于存储节点以及对应的深度
	type StackNode struct {
		Node  *TreeNode
		Depth int
	}

	// 初始化栈，先将根节点入栈
	stack := []StackNode{{Node: root, Depth: 1}}
	maxDepth := 0

	// 当栈不为空时，循环执行
	for len(stack) > 0 {
		// 出栈
		current := stack[len(stack)-1]
		stack = stack[:len(stack)-1]

		// 如果当前节点的深度大于已记录的最大深度，则更新最大深度
		if current.Depth > maxDepth {
			maxDepth = current.Depth
		}

		// 将当前节点的子节点入栈，深度为当前节点深度加1
		if current.Node.Left != nil {
			stack = append(stack, StackNode{Node: current.Node.Left, Depth: current.Depth + 1})
		}
		if current.Node.Right != nil {
			stack = append(stack, StackNode{Node: current.Node.Right, Depth: current.Depth + 1})
		}
	}

	// 返回记录的最大深度
	return maxDepth
}