14-二叉树最小深度-广度优先（BFS）

一、定义

什么是二叉树的最小深度？

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

举个例子：

     1
    / \
   2   3
  / 
 4

这棵树的最小深度是 2，因为从根节点 1 到叶子节点 3 的路径最短，只需要经过 1 和 3 两个节点。

---

广度优先搜索（BFS）的思路

广度优先搜索是一种遍历树的方法，它的特点是一层一层地遍历，先遍历离根节点最近的节点，再遍历离根节点稍远的节点。BFS 非常适合用来求解最小深度，因为它一旦找到第一个叶子节点，就可以立即返回结果。

用 BFS 求最小深度的步骤如下：

1. 从根节点开始，将其放入队列中。

2. 逐层遍历：

   • 每次从队列中取出一个节点，检查它是否是叶子节点（即没有左子树和右子树）。

   • 如果是叶子节点，直接返回当前深度。

   • 如果不是叶子节点，将它的子节点（左子节点和右子节点）加入队列。

3. 重复上述过程，直到找到第一个叶子节点。

---

举个例子

假设我们有一棵树：

复制

     1
    / \
   2   3
      / \
     4   5

用 BFS 计算最小深度的过程如下：

1. 初始化队列为 [1]，深度为 1。

2. 处理节点 1：

   • 它不是叶子节点，将它的子节点 2 和 3 加入队列。队列变为 [2, 3]。

3. 处理节点 2：

   • 它是叶子节点，返回当前深度 2。

所以这棵树的最小深度是 2。

二，举例

            1
           / \
          2   3
         / \   \
        4   5   6
                 \
                  7

import javax.swing.tree.TreeNode;
import java.util.LinkedList;
import java.util.Queue;

public class demo01 {
    public static void main(String[] args) {
        TreeNode node7 =new TreeNode(7,null,null);
        TreeNode node6 =new TreeNode(6,node7,null);
        TreeNode node5 =new TreeNode(5,null,null);
        TreeNode node4 =new TreeNode(4,null,null);
        TreeNode node3 =new TreeNode(3,node6,null);
        TreeNode node2 =new TreeNode(2,node4,node5);
        TreeNode node1 =new TreeNode(1,node2,node3);
        System.out.println(minDepth1(node1));
    }
    
    //深度优先
    public static int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        if (root.left == null && root.right == null) {
            return 1;
        }
        int min=Integer.MAX_VALUE;
        if(root.left != null) {                      //左边节点不为空
            min=Math.min(minDepth(root.left),min);    //算出左边节点
        }
        if(root.right != null) {                        //左边节点不为空
            min=Math.min(minDepth(root.right),min);   //算出左边节点
        }
        return min+1;
    }

    //广度优先
    public static int minDepth1(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        root.deep=1;
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (node.left == null && node.right == null) {
                return node.deep;
            }
            if (node.left != null) {            //左边节点不为空
                node.left.deep=node.deep+1;     //就入队
                queue.offer(node.left);
            }
            if (node.right != null) {           //左边节点不为空
                node.right.deep=node.deep+1;    //就入队
                queue.offer(node.right);
            }
        }
        return 0;
    }

    static class TreeNode {
        int deep;
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(int val,TreeNode left,TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}