博弈中的最小化策略：二叉树最小深度算法拆解

在计算机科学中，二叉树是一种常见的数据结构，它由一个根节点和一系列子节点组成。在二叉树中，每个节点都有最多两个子节点，分别是左子节点和右子节点。

二叉树的最小深度是指从根节点到最近的叶节点的最短路径的长度。叶节点是指没有子节点的节点。

计算二叉树的最小深度有两种常用的算法：深度优先搜索和广度优先搜索。

深度优先搜索是一种递归算法，它从根节点开始，依次遍历每一个节点的子节点，直到找到叶节点。当找到一个叶节点时，就记录下它的深度，并返回到上一个节点，继续遍历其他子节点。

广度优先搜索是一种迭代算法，它从根节点开始，将根节点的所有子节点加入队列中。然后，依次从队列中取出一个节点，将其所有子节点加入队列中，直到队列为空。当队列为空时，就找到了二叉树的最小深度。

深度优先搜索和广度优先搜索各有优缺点。深度优先搜索的优点是空间复杂度较低，只需要存储当前正在遍历的节点。广度优先搜索的优点是时间复杂度较低，因为它不需要回溯。

在实际应用中，可以选择使用深度优先搜索或广度优先搜索来计算二叉树的最小深度，具体取决于问题的具体情况。

class TreeNode:
  def __init__(self, val, left=None, right=None):
    self.val = val
    self.left = left
    self.right = right


def min_depth_dfs(root):
  if not root:
    return 0
  if not root.left and not root.right:
    return 1
  left_depth = min_depth_dfs(root.left)
  right_depth = min_depth_dfs(root.right)
  return min(left_depth, right_depth) + 1


def min_depth_bfs(root):
  if not root:
    return 0
  queue = [root]
  depth = 0
  while queue:
    size = len(queue)
    for _ in range(size):
      node = queue.pop(0)
      if not node.left and not node.right:
        return depth + 1
      if node.left:
        queue.append(node.left)
      if node.right:
        queue.append(node.right)
    depth += 1
  return depth


if __name__ == "__main__":
  # 构建二叉树
  root = TreeNode(1)
  root.left = TreeNode(2)
  root.right = TreeNode(3)
  root.left.left = TreeNode(4)
  root.left.right = TreeNode(5)

  # 计算最小深度
  print("最小深度（深度优先搜索）：", min_depth_dfs(root))
  print("最小深度（广度优先搜索）：", min_depth_bfs(root))