Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

Analysis:

we could solve this in recursive and iterative way. 

recursive, a little similar with maximum depth of binary tree. Different is to handle the situation that one subchild is null,

like [1,#,2].

java

public int minDepth(TreeNode root) {
        if(root == null) return 0;
        int left = minDepth(root.left);
        int right = minDepth(root.right);
        if(left == 0 && right ==0) return 1;
        if(left == 0) left = Integer.MAX_VALUE;
        if(right == 0) right = Integer.MAX_VALUE;
        return Math.min(left, right)+1;
    }
 

int minDepth(TreeNode *root) {
        if(root == NULL) return 0;
        int lmin = minDepth(root->left);
        int rmin = minDepth(root->right);
        if(lmin==0 && rmin == 0)
            return 1;
        if(lmin == 0)
            lmin = INT_MAX;
        if(rmin == 0)
            rmin = INT_MAX;
        return min(lmin, rmin)+1;
    }
 

Since the aim is to find the shortest path, the BFS is better. A queue is used to store every node from the binary tree in depth order. Pop each node, if there exist its left and right tree store it, otherwise if it is left node, return its depth. To store each node and its depth
c++

int minDepthBFS(TreeNode *root) {
    queue<pair<TreeNode*, int>> q;
    if(root == NULL) return 0;
    q.push(make_pair(root,1));
    while(!q.empty()){
        pair<TreeNode*, int> cur = q.front();
        q.pop();
        if(!cur.first->left && !cur.first->right) return cur.second;
        if(cur.first->left)
            q.push(make_pair(cur.first->left,cur.second+1));
        if(cur.first->right)
            q.push(make_pair(cur.first->right,cur.second+1));
    }
}

public int minDepthBFS(TreeNode root){
		if(root == null) return 0;
		ArrayList<TreeNode> last = new ArrayList<TreeNode>();
		last.add(root);
		int count =1;
		while(!last.isEmpty()){
			ArrayList<TreeNode> cur = new ArrayList<TreeNode>();
			for (TreeNode treeNode : last) {
				if(treeNode.left == null && treeNode.right == null) return count;
				if(treeNode.left != null) cur.add(treeNode.left);
				if(treeNode.right != null) cur.add(treeNode.right);
			}
			count++;
			last = new ArrayList<TreeNode>(cur);
		}
		return count;
	}