## DEV Community is a community of 604,099 amazing developers

We're a place where coders share, stay up-to-date and grow their careers.

loading... # Solution: Average of Levels in Binary Tree

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.

#### 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:

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:

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

#### 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:

The code for all four languages is almost identical.

#### 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:

(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:

(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:

(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;
}
};
``````

## Discussion (0) 