Leetcode 111. Minimum Depth of Binary Tree

方法1: 依旧是recursion。时间复杂n，空间复杂height of the tree，best case logn， worst case n。

/**
 * 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;
        TreeNode left = root.left;
        TreeNode right = root.right;
        if(left == null) return minDepth(right) + 1;
        if(right == null) return minDepth(left) + 1;
        return Math.min(minDepth(left),minDepth(right)) + 1;
    }
}

方法2: dfs。时间复杂n，空间复杂height of the tree，best case logn，worst case n。

/**
 * 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;
        Stack<TreeNode> stack = new Stack<>();
        Stack<Integer> depths = new Stack<>();
        int curr_depth = 0;
        stack.push(root);
        depths.push(1);
        int res = Integer.MAX_VALUE;
        while(!stack.empty()) {
            root = stack.pop();
            curr_depth = depths.pop();
            if(root.left == null && root.right == null){
                res = Math.min(res,curr_depth);
            }else if(root.left == null) {
                stack.push(root.right);
                depths.push(curr_depth + 1);
            }else if(root.right == null){
                stack.push(root.left);
                depths.push(curr_depth + 1);
            }else{
                stack.add(root.left);
                stack.add(root.right);
                depths.push(curr_depth + 1);
                depths.push(curr_depth + 1);
            } 
        }
        return res;
    }
}

方法3: bfs。时间复杂height of the tree， worst case n，best case logn。空间复杂n。

/**
 * 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;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int depth = 0;
        while(!queue.isEmpty()){
            int size = queue.size();
            depth++;
            while(size > 0){
                root = queue.poll();
                if(root.left == null && root.right == null){
                    return depth;
                }else if(root.left == null){
                    queue.offer(root.right);
                }else if(root.right == null){
                    queue.offer(root.left);
                }else{
                    queue.offer(root.left);
                    queue.offer(root.right);
                }
                size--;
            }  
        }
        return depth;
    }
}

总结：

• 此题和104题非常类似，两题记得联系起来一起看。