给定一个二叉树，找出其最小深度。
    最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
    解法一：深度优先
    遍历整颗数，找到每一个叶子节点，从叶子节点往上开始计算，左右子节点都为空则记录深度为1
    左右子节点只有一边，深度记录为子节点深度+1
    左右两边都有子节点，则记录左右子节点的深度较小值+1

    1. public int minDepth(TreeNode root) {
    2.     if (root == null) {
    3.         return 0;
    4.     }
    6.     if ((root.left == null) && (root.right == null)) {
    7.         return 1;
    8.     }
    10.     int min_depth = Integer.MAX_VALUE;
    12.     if (root.left != null) {
    13.         min_depth = Math.min(minDepth(root.left), min_depth);
    14.     }
    16.     if (root.right != null) {
    17.         min_depth = Math.min(minDepth(root.right), min_depth);
    18.     }
    20.     return min_depth + 1;
    21. }

    时间复杂度：O(N)
    空间复杂度：O(logN) 取决于树的高度

    解法二：广度优先
    从上往下，找到一个节点时，标记这个节点的深度。查看该节点是否为叶子节点，如果是直接返回深度
    如果不是叶子节点，将其子节点标记深度(在父节点深度的基础上加1)，再判断该节点是否为叶子节点

    1. public int minDepth(TreeNode root) {
    2.     if (root == null) {
    3.         return 0;
    4.     }
    6.     Queue<QueueNode> queue = new LinkedList<QueueNode>();
    7.     queue.offer(new QueueNode(root, 1));
    9.     while (!queue.isEmpty()) {
    10.         QueueNode nodeDepth = queue.poll();
    11.         TreeNode node = nodeDepth.node;
    12.         int depth = nodeDepth.depth;
    14.         if ((node.left == null) && (node.right == null)) {
    15.             return depth;
    16.         }
    18.         if (node.left != null) {
    19.             queue.offer(new QueueNode(node.left, depth + 1));
    20.         }
    22.         if (node.right != null) {
    23.             queue.offer(new QueueNode(node.right, depth + 1));
    24.         }
    25.     }
    27.     return 0;
    28. }
    30. class QueueNode {
    31.     TreeNode node;
    32.     int depth;
    34.     public QueueNode(TreeNode node, int depth) {
    35.         this.node = node;
    36.         this.depth = depth;
    37.     }
    38. }

    时间复杂度：O(N)
    空间复杂度：O(N)