Minimum Depth of Binary Tree

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: Recursive. Note that -1 is used as a flag which indicates left/right subtree is empty and the current node is not a leaf. 

Update 02/11/2014: 

Shortest path -> BFS. 

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int minDepth(TreeNode root) {
        if(root==null) return 0;
        int min = 0;
        Queue<TreeNode> frontier = new LinkedList<TreeNode>();
        frontier.add(root);
        while(!frontier.isEmpty()) {
            Queue<TreeNode> next = new LinkedList<TreeNode>();
            min++;
            while(!frontier.isEmpty()) {
                TreeNode current = frontier.poll();
                if(current.left==null && current.right==null) {
                    next.clear();
                    break;
                }
                if(current.left!=null) next.add(current.left);
                if(current.right!=null) next.add(current.right);
            }
            frontier = next;
        }
        return min;
    }
}

Update 02/06/2014: 

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int minDepth(TreeNode root) {
        if(root==null) return 0;
        int ldepth = minDepth(root.left);
        int rdepth = minDepth(root.right);
        if(ldepth==0) return rdepth+1;      // left subtree is empty
        else if(rdepth==0) return ldepth+1; // right subtree is empty
        else return Math.min(ldepth, rdepth)+1;
    }
}

Version1: 

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int minDepth(TreeNode root) {
        if(root==null) return 0;
        if(root.left==null && root.right==null) return 1;
        int ldepth=-1, rdepth=-1;
        if(root.left!=null) ldepth=minDepth(root.left)+1;
        if(root.right!=null) rdepth=minDepth(root.right)+1;
        
        if(ldepth==-1) return rdepth;
        else if(rdepth==-1) return ldepth;
        else return (ldepth<=rdepth ? ldepth : rdepth);
    }
}

Version2: 

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int helper(TreeNode root, int depth) {
        if(root==null) return 0;
        depth++;
        if(root.left==null && root.right==null) return depth;       // leaf nodes
        int ldepth=-1, rdepth=-1;
        if(root.left!=null) ldepth=helper(root.left, depth);
        if(root.right!=null) rdepth=helper(root.right, depth);
        if(ldepth==-1) return rdepth;
        else if(rdepth==-1) return ldepth;
        else return (ldepth<=rdepth ? ldepth : rdepth);
    }
    
    public int minDepth(TreeNode root) {
        return helper(root, 0);
    }
}