给定一个二叉树，找出其最小深度。
    最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
    深度优先、广度优先

    1. public class TreeDeep {
    2.     static class TreeNode {
    3.         int val;
    4.         TreeNode left;
    5.         TreeNode right;
    6.         int deep;
    8.         public TreeNode(int val, TreeNode left, TreeNode right) {
    9.             this.val = val;
    10.             this.left = left;
    11.             this.right = right;
    12.         }
    13.     }
    15.     public static void main(String[] args) {
    16.         TreeNode node7 = new TreeNode(7, null, null);
    17.         TreeNode node6 = new TreeNode(6, node7, null);
    18.         TreeNode node5 = new TreeNode(5, null, null);
    19.         TreeNode node4 = new TreeNode(4, null, null);
    20.         TreeNode node3 = new TreeNode(3, node6, null);
    21.         TreeNode node2 = new TreeNode(2, node4, node5);
    22.         TreeNode node1 = new TreeNode(1, node2, node3);
    23.         System.out.println(minDepth(node1));
    24.         System.out.println(minDepth2(node1));
    25.     }
    27.     //深度优先
    28.     private static int minDepth(TreeNode root) {
    29.         if (root == null) {
    30.             return 0;
    31.         }
    32.         if (root.left == null && root.right == null) {
    33.             return 1;
    34.         }
    35.         int min = Integer.MAX_VALUE;
    36.         if (root.left != null) {
    37.             min = Math.min(minDepth(root.left), min);
    38.         }
    39.         if (root.right != null) {
    40.             min = Math.min(minDepth(root.right), min);
    41.         }
    42.         return min + 1;
    43.     }
    45.     //广度优先
    46.     private static int minDepth2(TreeNode root) {
    47.         if (root == null) {
    48.             return 0;
    49.         }
    50.         Queue<TreeNode> queue = new LinkedList();
    51.         root.deep = 1;
    52.         queue.offer(root);
    53.         while (!queue.isEmpty()) {
    54.             TreeNode node = queue.poll();
    55.             if (node.left == null && node.right == null) {
    56.                 return node.deep;
    57.             }
    58.             if (node.left != null) {
    59.                 node.left.deep = node.deep + 1;
    60.                 queue.offer(node.left);
    61.             }
    62.             if (node.right != null) {
    63.                 node.right.deep = node.deep + 1;
    64.                 queue.offer(node.right);
    65.             }
    66.         }
    67.         return 0;
    68.     }
    69. }