添加 0102.二叉树的层序遍历.md Java版本

problems/0102.二叉树的层序遍历.md

@@ -420,54 +420,236 @@ public:
 Java：
 
 ```Java
+// 102.二叉树的层序遍历
 class Solution {
-    public List<List<Integer>> resList=new ArrayList<List<Integer>>();
+    public List<List<Integer>> resList = new ArrayList<List<Integer>>();
+
     public List<List<Integer>> levelOrder(TreeNode root) {
         //checkFun01(root,0);
         checkFun02(root);
-        
+
         return resList;
     }
 
-	//DFS--递归方式
-    public void checkFun01(TreeNode node,Integer deep){
-        if(node==null) return;
+    //DFS--递归方式
+    public void checkFun01(TreeNode node, Integer deep) {
+        if (node == null) return;
         deep++;
 
-        if(resList.size()<deep){
+        if (resList.size() < deep) {
             //当层级增加时，list的Item也增加，利用list的索引值进行层级界定
-            List<Integer> item=new ArrayList<Integer>();
+            List<Integer> item = new ArrayList<Integer>();
             resList.add(item);
         }
-        resList.get(deep-1).add(node.val);
-        
-        checkFun01(node.left,deep);
-        checkFun01(node.right,deep);
+        resList.get(deep - 1).add(node.val);
+
+        checkFun01(node.left, deep);
+        checkFun01(node.right, deep);
     }
-    
+
     //BFS--迭代方式--借助队列
-     public void checkFun02(TreeNode node){
-        if(node==null) return;
-        Queue<TreeNode> que=new LinkedList<TreeNode>();
+    public void checkFun02(TreeNode node) {
+        if (node == null) return;
+        Queue<TreeNode> que = new LinkedList<TreeNode>();
         que.offer(node);
 
-        while(!que.isEmpty()){
-            List<Integer> itemList=new ArrayList<Integer>();
-            int len=que.size();
+        while (!que.isEmpty()) {
+            List<Integer> itemList = new ArrayList<Integer>();
+            int len = que.size();
 
-            while(len>0){
-                TreeNode tmpNode=que.poll();
+            while (len > 0) {
+                TreeNode tmpNode = que.poll();
                 itemList.add(tmpNode.val);
 
-                if(tmpNode.left!=null) que.offer(tmpNode.left);
-                if(tmpNode.right!=null) que.offer(tmpNode.right);
+                if (tmpNode.left != null) que.offer(tmpNode.left);
+                if (tmpNode.right != null) que.offer(tmpNode.right);
                 len--;
             }
-            
+
             resList.add(itemList);
         }
 
     }
+}
+    
+
+// 107. 二叉树的层序遍历 II
+public class N0107 {
+
+    /**
+     * 解法：队列，迭代。
+     * 层序遍历，再翻转数组即可。
+     */
+    public List<List<Integer>> solution1(TreeNode root) {
+        List<List<Integer>> list = new ArrayList<>();
+        Deque<TreeNode> que = new LinkedList<>();
+
+        if (root == null) {
+            return list;
+        }
+
+        que.offerLast(root);
+        while (!que.isEmpty()) {
+            List<Integer> levelList = new ArrayList<>();
+
+            int levelSize = que.size();
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode peek = que.peekFirst();
+                levelList.add(que.pollFirst().val);
+
+                if (peek.left != null) {
+                    que.offerLast(peek.left);
+                }
+                if (peek.right != null) {
+                    que.offerLast(peek.right);
+                }
+            }
+            list.add(levelList);
+        }
+
+        List<List<Integer>> result = new ArrayList<>();
+        for (int i = list.size() - 1; i >= 0; i-- ) {
+            result.add(list.get(i));
+        }
+
+        return result;
+    }
+}
+
+// 199.二叉树的右视图
+public class N0199 {
+    /**
+     * 解法：队列，迭代。
+     * 每次返回每层的最后一个字段即可。
+     *
+     * 小优化：每层右孩子先入队。代码略。
+     */
+    public List<Integer> rightSideView(TreeNode root) {
+        List<Integer> list = new ArrayList<>();
+        Deque<TreeNode> que = new LinkedList<>();
+
+        if (root == null) {
+            return list;
+        }
+
+        que.offerLast(root);
+        while (!que.isEmpty()) {
+            int levelSize = que.size();
+
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode poll = que.pollFirst();
+
+                if (poll.left != null) {
+                    que.addLast(poll.left);
+                }
+                if (poll.right != null) {
+                    que.addLast(poll.right);
+                }
+
+                if (i == levelSize - 1) {
+                    list.add(poll.val);
+                }
+            }
+        }
+
+        return list;
+    }
+}
+
+// 637. 二叉树的层平均值
+public class N0637 {
+
+    /**
+     * 解法：队列，迭代。
+     * 每次返回每层的最后一个字段即可。
+     */
+    public List<Double> averageOfLevels(TreeNode root) {
+        List<Double> list = new ArrayList<>();
+        Deque<TreeNode> que = new LinkedList<>();
+
+        if (root == null) {
+            return list;
+        }
+
+        que.offerLast(root);
+        while (!que.isEmpty()) {
+            TreeNode peek = que.peekFirst();
+
+            int levelSize = que.size();
+            double levelSum = 0.0;
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode poll = que.pollFirst();
+
+                levelSum += poll.val;
+
+                if (poll.left != null) {
+                    que.addLast(poll.left);
+                }
+                if (poll.right != null) {
+                    que.addLast(poll.right);
+                }
+            }
+            list.add(levelSum / levelSize);
+        }
+        return list;
+    }
+}
+
+// 429. N 叉树的层序遍历
+public class N0429 {
+    /**
+     * 解法1：队列，迭代。
+     */
+    public List<List<Integer>> levelOrder(Node root) {
+        List<List<Integer>> list = new ArrayList<>();
+        Deque<Node> que = new LinkedList<>();
+
+        if (root == null) {
+            return list;
+        }
+
+        que.offerLast(root);
+        while (!que.isEmpty()) {
+            int levelSize = que.size();
+            List<Integer> levelList = new ArrayList<>();
+
+            for (int i = 0; i < levelSize; i++) {
+                Node poll = que.pollFirst();
+
+                levelList.add(poll.val);
+
+                List<Node> children = poll.children;
+                if (children == null || children.size() == 0) {
+                    continue;
+                }
+                for (Node child : children) {
+                    if (child != null) {
+                        que.offerLast(child);
+                    }
+                }
+            }
+            list.add(levelList);
+        }
+
+        return list;
+    }
+
+    class Node {
+        public int val;
+        public List<Node> children;
+
+        public Node() {}
+
+        public Node(int _val) {
+            val = _val;
+        }
+
+        public Node(int _val, List<Node> _children) {
+            val = _val;
+            children = _children;
+        }
+    }
+}
 ```