技術標籤：演算法二叉樹dfsleetcode資料結構

題目：
給定一個二叉樹，找出其最小深度。最小深度是從根節點到最近葉子節點的最短路徑上的節點數量。
說明：葉子節點是指沒有子節點的節點。

示例 1：
輸入：root = [3,9,20,null,null,15,7]
輸出：2

示例 2：
輸入：root = [2,null,3,null,4,null,5,null,6]
輸出：5

提示：
樹中節點數的範圍在 [0, 105] 內
-1000 <= Node.val <= 1000

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/minimum-depth-of-binary-tree

解題思路：
注意題目是需要我們找出最小深度，可以分解的來看這個條件，最小深度是找葉子節點，然後再是找到葉子節點中的深度最小的。我們可以採取遞迴的求解，可以使用兩種演算法：

一、使用深度優先搜尋

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
 

class Solution {
    public int minDepth(TreeNode root) {
        return dfs(root);
    }

    public int dfs(TreeNode root){
        int l,r;
        if(root==null)
            return 0;
        l = dfs(root.left);
        r = dfs(root.right);
        if(l==0)
            return ++r;
        if(r==0)
 

            return ++l;
        return Math.min(r,l)+1;
    }

}

二、使用廣度優先搜尋

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        if(root==null){
            return 0;
        }else{
            ArrayList<TreeNode> nodes = new ArrayList();
            nodes.add(root);
            return gfs(nodes, 0);
        }
    }

    public int gfs(ArrayList<TreeNode> nodes, int depth){
        ArrayList<TreeNode> newNodes = new ArrayList();

        for(TreeNode node : nodes){
            if(node.left==null && node.right==null)
                return ++depth;
            if(node.left!=null)
                newNodes.add(node.left);
            if(node.right!=null)
                newNodes.add(node.right);
        }

        return gfs(newNodes, ++depth);
    }
}

結果：

廣度優先演算法執行時間只有1ms相對深度優先搜尋快了很多，但是程式碼相對來說要的複雜一點。