【LeetCode】Minimum Depth of Binary Tree 二叉树的最小深度 java

【LeetCode】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.

递归和非递归，此提比较简单。广度优先遍历即可。关键之处就在于如何保持访问深度。

下面是4种代码：

  1 import java.util.ArrayList;
  2 import java.util.LinkedList;
  3 import java.util.List;
  4 import java.util.Queue;
  5 
  6 class TreeNode {
  7     int val;
  8     TreeNode left;
  9     TreeNode right;
 10 
 11     TreeNode(int x) {
 12         val = x;
 13     }
 14 }
 15 public class MinimumDepthofBinaryTree {
 16     /**
 17      * 递归深度遍历 
 18      * @param root
 19      * @return
 20      */
 21     public int minDepth1(TreeNode root) {
 22         if(root==null)
 23             return 0;
 24         if(root.left==null&&root.right==null){
 25             return 1;
 26         }
 27         int left=minDepth1(root.left);
 28         int right=minDepth1(root.right);
 29         if(left==0){
 30             return right+1;
 31         }
 32         if(right==0){
 33             return left+1;
 34         }
 35         else{
 36             return Math.min(right, left)+1;
 37         }
 38     }
 39     public int minDepth2(TreeNode root) {
 40         if(root==null)
 41             return 0;
 42         int left=minDepth1(root.left);
 43         int right=minDepth1(root.right);
 44         
 45         if(left==0&&right==0){
 46             return 1;
 47         }
 48         if(left==0){
 49             right= Integer.MAX_VALUE;
 50         }
 51         if(right==0){
 52             left=Integer.MAX_VALUE;
 53         }
 54         
 55             return Math.min(right, left)+1;
 56         
 57     }
 58 
 59     /**
 60      * 广度优先搜索。一旦发现叶子结点，返回遍历深度。
 61      * @param root
 62      * @return
 63      */
 64     public int minDepth3(TreeNode root) {
 65         if(root==null){
 66             return 0;
 67         }
 68         Queue<TreeNode>queue=new LinkedList<>();
 69         queue.add(root);
 70         int count=queue.size();//用来保存访问当前层次剩余未访问的节点。
 71         int depth=1;//用来保存二叉树的访问深度
 72         while(!queue.isEmpty()){
 73             //广度遍历
 74             TreeNode topNode=queue.poll();
 75             count--;
 76             if(topNode.left!=null){
 77                 queue.add(topNode.left);
 78             }
 79             if(topNode.right!=null){
 80                 queue.add(topNode.right);
 81             }
 82             //发现叶子节点
 83             if(topNode.left==null&&topNode.right==null){
 84                 return depth;
 85             }
 86             //访问一层完毕
 87             if(count==0){
 88                 depth++;
 89                 count=queue.size();
 90             }
 91             
 92         }
 93         return 0;
 94     }
 95     /**
 96      * 广度优先搜索。一旦发现叶子结点，返回遍历深度。
 97      * @param root
 98      * @return
 99      */
100     public int minDepth4(TreeNode root) {
101         if(root==null){
102             return 0;
103         }
104         List<TreeNode>list=new ArrayList<>();
105         int count=1;
106         list.add(root);
107         while(list.size()!=0){
108             List<TreeNode>singleList=new ArrayList<>();
109             for(TreeNode t:list){
110                 if(t.left!=null){
111                     singleList.add(t.left);
112                 }if(t.right!=null){
113                     singleList.add(t.right);
114                 }
115                 if(t.left==null&&t.right==null){
116                 return count;    
117                 }
118             }
119             count++;
120             list=singleList;
121         }
122         return 0;
123     }
124     public static void main(String[] args) {
125         TreeNode rootNode1 = new TreeNode(1);
126         TreeNode rootNode2 = new TreeNode(2);
127         TreeNode rootNode3 = new TreeNode(3);
128         TreeNode rootNode4 = new TreeNode(4);
129         TreeNode rootNode5 = new TreeNode(5);
130         TreeNode rootNode6 = new TreeNode(6);
131         TreeNode rootNode7 = new TreeNode(7);
132         rootNode1.left = rootNode2;
133         rootNode1.right = rootNode3;
134         rootNode2.left = rootNode4;
135         rootNode2.right = rootNode5;
136         rootNode3.left = rootNode6;
137         rootNode3.right = rootNode7;
138         MinimumDepthofBinaryTree  minimumDepthofBinaryTree=new MinimumDepthofBinaryTree();
139         System.out.println(minimumDepthofBinaryTree.minDepth4(rootNode1));
140 
141     }
142     
143 }