solve problem Average Of Levels In Binary Tree

Author: P-ppc

README.md

@@ -55,6 +55,7 @@ All solutions will be accepted!
 |83|[Remove Duplicates From Sorted List](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/description/)|[java/py/js](./algorithms/RemoveDuplicatesFromSortedList)|Easy|
 |82|[Remove Duplicates From Sorted List II](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list-ii/description/)|[java/py/js](./algorithms/RemoveDuplicatesFromSortedListII)|Medium|
 |811|[Subdomain Visit Count](https://leetcode-cn.com/problems/subdomain-visit-count/description/)|[java/py/js](./algorithms/SubdomainVisitCount)|Easy|
+|637|[Average Of Levels In Binary Tree](https://leetcode-cn.com/problems/average-of-levels-in-binary-tree/description/)|[java/py/js](./algorithms/AverageOfLevelsInBinaryTree)|Easy|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/AverageOfLevelsInBinaryTree/README.md

@@ -0,0 +1,2 @@
+# Average Of Levels In Binary Tree
+This problem is easy to solve

algorithms/AverageOfLevelsInBinaryTree/Solution.java

@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public List<Double> averageOfLevels(TreeNode root) {
+        List<Double> res = new ArrayList<Double>();
+        List<TreeNode> level = new ArrayList<TreeNode>();
+        if (root != null) level.add(root);
+        
+        while (level.size() > 0) {
+            List<TreeNode> tempLevel = new ArrayList<TreeNode>();
+            Double sum = 0D;
+            for (TreeNode node : level) {
+                sum += node.val;
+                if (node.left != null) tempLevel.add(node.left);
+                if (node.right != null) tempLevel.add(node.right);
+            }
+            
+            res.add(sum / level.size());
+            level = tempLevel;
+        }
+        return res;
+    }
+}

algorithms/AverageOfLevelsInBinaryTree/solution.js

@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var averageOfLevels = function(root) {
+    
+    let res = [],
+        level = root === null ? [] : [root]
+    
+    while (level.length > 0) {
+        res.push(level.reduce((x, y) => x + y.val, 0) / level.length)
+        temp = []
+        level.forEach(node => {
+            if (node.left) temp.push(node.left)   
+            if (node.right) temp.push(node.right)
+        })
+        level = temp
+    }
+    
+    return res
+};

algorithms/AverageOfLevelsInBinaryTree/solution.py

@@ -0,0 +1,27 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def averageOfLevels(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[float]
+        """
+        if not root:
+            return []
+        res = []
+        level = [root]
+        while len(level) > 0:
+            res.append(sum([x.val for x in level]) / (len(level) * 1.0))
+            temp = []
+            for node in level:
+                if node.left:
+                    temp.append(node.left)
+                if node.right:
+                    temp.append(node.right)
+            level = temp
+        return res