1 /**
 2  * Definition of TreeNode:
 3  * public class TreeNode {
 4  *     public int val;
 5  *     public TreeNode left, right;
 6  *     public TreeNode(int val) {
 7  *         this.val = val;
 8  *         this.left = this.right = null;
 9  *     }
10  * }
11  */
12
13 public class Solution {
14     /**
15      * @param root: A Tree
16      * @return: Level order a list of lists of integer
17      */
18     public List<List<Integer>> levelOrder(TreeNode root) {
19         // write your code here
20         List<List<Integer>> results = new ArrayList<>();
21         if(root == null){
22             return results;
23         }
24         //interface offer(add) poll(pop)
25         Queue<TreeNode> queue = new LinkedList<>();
26         //put start node into queue
27         queue.offer(root);
28
29         while(!queue.isEmpty()){
30             //lever x->x+1
31             ArrayList<Integer> currentLevel = new ArrayList();
32             int size = queue.size();
33             for(int i =0; i<size;i++){
34                 TreeNode head = queue.poll();
35                 currentLevel.add(head.val);
36                 if(head.left != null){
37                     queue.offer(head.left);
38                 }
39                 if(head.right != null){
40                     queue.offer(head.right);
41                 }
42             }
43             results.add(currentLevel);
44         }
45
46         return results;
47
48
49     }
50 }

 1 public class Solution {
 2     /**
 3      * @param n: An integer
 4      * @param edges: a list of undirected edges
 5      * @return: true if it's a valid tree, or false
 6      */
 7     public boolean validTree(int n, int[][] edges) {
 8         // write your code here
 9         if(n==0){
10             return false;
11         }
12
13         if(edges.length != n-1){
14             return false;
15         }
16         //adjacent lists
17         Map<Integer,Set<Integer>> graph = initializeGraph(n,edges);
18
19         Queue<Integer> queue = new LinkedList<>();
20         Set<Integer> hash = new HashSet<>();
21
22         queue.offer(0);
23         hash.add(0);
24
25         while(!queue.isEmpty()){
26             int node = queue.poll();
27             for(Integer neigh:graph.get(node)){
28                 if(hash.contains(neigh)){
29                     continue;
30                 }
31                 hash.add(neigh);
32                 queue.offer(neigh);
33             }
34         }
35         return hash.size()==n;
36
37     }
38
39     private Map<Integer,Set<Integer>> initializeGraph(int n,int[][]edges){
40         Map<Integer,Set<Integer>> graph = new HashMap<>();
41         for(int i=0;i<n;i++){
42             graph.put(i,new HashSet<>());
43         }
44         for(int i =0;i<edges.length;i++){
45             int u = edges[i][0];
46             int v = edges[i][1];
47             graph.get(u).add(v);
48             graph.get(v).add(u);
49         }
50         return graph;
51     }
52 }