*This is part of a series of Leetcode solution explanations (index). If you liked this solution or found it useful,* *please like**this post and/or* *upvote**my solution post on Leetcode's forums.*

####
Leetcode Problem #637 (*Easy*): Average of Levels in Binary Tree

####
*Description:*

*Description:*

(*Jump to*: *Solution Idea* || *Code*: *JavaScript* | *Python* | *Java* | *C++*)

Given a non-empty binary tree, return the average value of the nodes on each level in the form of an array.

####
*Examples:*

*Examples:*

Example 1: Input: Output: [3, 14.5, 11] Explanation: The average value of nodes on level 0 is 3,

on level 1 is 14.5, and on level 2 is 11.

Hence return [3, 14.5, 11].

####
*Constraints:*

*Constraints:*

- The range of node's value is in the range of 32-bit signed integer.

####
*Idea:*

*Idea:*

(*Jump to*: *Problem Description* || *Code*: *JavaScript* | *Python* | *Java* | *C++*)

A problem talking about levels in a binary tree should immediately bring to mind a **breadth-first search** (**BFS**) approach. The classic BFS approach for a binary tree is to use a **queue** and push each queue entry's children onto the end of the queue. This way, the queue will run to the end of the row/level before moving onto the next level.

When a problem requires you to isolate a level, you can simply take the length of the queue at the start of the row and then once you've processed that many nodes from the queue, you'll know that you're ready to start the next row.

So as long as the queue exists, we'll take each row, sum the row's values (**row**), then divide by the length of the row (**qlen**) to find the average, pushing each average into our answer array (**ans**).

####
*Implementation:*

*Implementation:*

The code for all four languages is almost identical.

####
*Javascript Code:*

*Javascript Code:*

(*Jump to*: *Problem Description* || *Solution Idea*)

```
var averageOfLevels = function(root) {
let q = [root], ans = []
while (q.length) {
let qlen = q.length, row = 0
for (let i = 0; i < qlen; i++) {
let curr = q.shift()
row += curr.val
if (curr.left) q.push(curr.left)
if (curr.right) q.push(curr.right)
}
ans.push(row/qlen)
}
return ans
};
```

####
*Python Code:*

*Python Code:*

(*Jump to*: *Problem Description* || *Solution Idea*)

```
class Solution:
def averageOfLevels(self, root: TreeNode) -> List[float]:
q, ans = [root], []
while len(q):
qlen, row = len(q), 0
for i in range(qlen):
curr = q.pop(0)
row += curr.val
if curr.left: q.append(curr.left)
if curr.right: q.append(curr.right)
ans.append(row/qlen)
return ans
```

####
*Java Code:*

*Java Code:*

(*Jump to*: *Problem Description* || *Solution Idea*)

```
class Solution {
public List<Double> averageOfLevels(TreeNode root) {
Queue<TreeNode> q = new LinkedList<>(List.of(root));
List<Double> ans = new ArrayList<>();
while (q.size() > 0) {
double qlen = q.size(), row = 0;
for (int i = 0; i < qlen; i++) {
TreeNode curr = q.poll();
row += curr.val;
if (curr.left != null) q.offer(curr.left);
if (curr.right != null) q.offer(curr.right);
}
ans.add(row/qlen);
}
return ans;
}
}
```

####
*C++ Code:*

*C++ Code:*

(*Jump to*: *Problem Description* || *Solution Idea*)

```
class Solution {
public:
vector<double> averageOfLevels(TreeNode* root) {
queue<TreeNode*> q;
q.push(root);
vector<double> ans;
while (q.size()) {
double qlen = q.size(), row = 0;
for (int i = 0; i < qlen; i++) {
TreeNode* curr = q.front(); q.pop();
row += curr->val;
if (curr->left) q.push(curr->left);
if (curr->right) q.push(curr->right);
}
ans.push_back(row/qlen);
}
return ans;
}
};
```

## Top comments (0)