題目連結:https://leetcode.com/problems/minimum-depth-of-binary-tree/

求樹的最小深度，也就是說:沿著樹的路徑從根節點到最近葉節點的距離。

需要一個佇列進行層次遍歷（BFS,對層次進行計數），在某一層找到葉節點時返回。

class Solution {
    public static int minDepth(TreeNode root) 
	{
		
		if(root==null)
			return 0;
		Queue<TreeNode> q=new LinkedList<TreeNode>();
		q.add(root);
		int count=0;
		while(!q.isEmpty())
		{
			count++;
			int len=q.size();
			for(int i=0;i<len;i++)
			{
				TreeNode node=q.poll();
				if(node.left!=null)
					q.add(node.left);
				if(node.right!=null)
					q.add(node.right);
				if(node.left==null && node.right==null)
					return count;
			}
			
		}
		return count;
	}
}
 

另外一種BFS解法空間複雜度比上面的大一點，但是比後面的DFS具體執行時間少一點（不用遍歷所有樹節點）：

import javafx.util.Pair;
class Solution {
    public int minDepth(TreeNode root) {
        Queue<Pair<TreeNode,Integer>> records=new LinkedList<Pair<TreeNode,Integer>>();
        if(root==null)
            return 0;
        records.add(new Pair(root,1));

        int min=1;
        
        while(!records.isEmpty())
        {
            Pair<TreeNode,Integer> temp=records.poll();
            TreeNode currentNode=temp.getKey();
            int depth=temp.getValue();
            min=depth;
            if(currentNode.left==null && currentNode.right==null)
                break;
            if(currentNode.left!=null)
                records.add(new Pair(currentNode.left,depth+1));
            if(currentNode.right!=null)
                records.add(new Pair(currentNode.right,depth+1));
        }
        return min;
    }
}
 

再來看看遞迴解法，遞迴解法與樹的最大深度解法類似（https://blog.csdn.net/To_be_to_thought/article/details/84555289）：

class Solution {
    public 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(min,minDepth(root.left));
        if(root.right!=null)
            min=Math.min(min,minDepth(root.right));
        return min+1;
    }
}
 

基於棧的深度優先搜尋：

import javafx.util.Pair;
class Solution {
    public int minDepth(TreeNode root) {
        Stack<Pair<TreeNode,Integer>> records=new Stack<Pair<TreeNode,Integer>>();
        if(root==null)
            return 0;
        records.add(new Pair(root,1));

        int min=Integer.MAX_VALUE;
        
        while(!records.isEmpty())
        {
            Pair<TreeNode,Integer> temp=records.pop();
            TreeNode currentNode=temp.getKey();
            int depth=temp.getValue();
            
            if(currentNode.left==null && currentNode.right==null)
                min=Math.min(min,depth);;
            if(currentNode.left!=null)
                records.add(new Pair(currentNode.left,depth+1));
            if(currentNode.right!=null)
                records.add(new Pair(currentNode.right,depth+1));
        }
        return min;
    }
}