LeetCode------Minimum Depth of Binary Tree

二叉树的经典问题之最小深度问题就是就最短路径的节点个数，还是用深度优先搜索DFS来完成。

递归

package com.zhumq.lianxi;

public class MinDepth {
    //定义TreeNode
    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(int x) { val = x; }
    }
    public int minDepth(TreeNode root) {
        if (root == null) return 0;
        if (root.left == null && root.right == null) return 1;

        if (root.left == null) 
            //没有左孩子时，当前节点的最小深度为右孩子最小深度+1
            return minDepth(root.right) + 1;
        else if (root.right == null) 
            //同理没有左孩子时，当前节点的最小深度为左孩子的最小深度+1
            return minDepth(root.left) + 1;
        else 
            //左右孩子都存在时，当前节点的最小深度为两者最小值+1
            return 1 + Math.min(minDepth(root.left), minDepth(root.right));
    }
}

迭代

// Minimum Depth of Binary Tree
// 迭代版，时间复杂度O(n)，空间复杂度O(logn)
public class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) return 0;
        int result = Integer.MAX_VALUE;
        Stack<Pair> s = new Stack<>();
        s.push(new Pair(root, 1));
        while (!s.empty()) {
            final Pair p = s.pop();
            TreeNode node = p.node;
            int depth = p.depth;
            if (node.left == null && node.right == null)
                result = Math.min(result, depth);
            if (node.left != null && result > depth) // 深度控制，剪枝
                s.push(new Pair(node.left, depth + 1));
            if (node.right != null && result > depth) // 深度控制，剪枝
                s.push(new Pair(node.right, depth + 1));
        } 
        return result;
    } 

    static class Pair {
        TreeNode node;
        int depth;
        public Pair(TreeNode node, int depth) {
            this.node = node;
            this.depth = depth;
        }
    }
}