Average of Levels in Binary Tree

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> ans;
        queue<TreeNode*> q;
        q.push(root);
        while (!q.empty()) {
            int sz = q.size();
            long long sum = 0;
            for (int i = 0; i < sz; ++i) {
                TreeNode* cur = q.front(); q.pop();
                sum += cur->val;
                if (cur->left)  q.push(cur->left);
                if (cur->right) q.push(cur->right);
            }
            ans.push_back(static_cast<double>(sum) / sz);
        }
        return ans;
    }
};

func averageOfLevels(root *TreeNode) []float64 {
    ans := []float64{}
    q := []*TreeNode{root}
    for len(q) > 0 {
        sz := len(q)
        var sum int64 = 0
        for i := 0; i < sz; i++ {
            cur := q[i]
            sum += int64(cur.Val)
            if cur.Left != nil {
                q = append(q, cur.Left)
            }
            if cur.Right != nil {
                q = append(q, cur.Right)
            }
        }
        q = q[sz:]
        ans = append(ans, float64(sum)/float64(sz))
    }
    return ans
}

from collections import deque
from typing import List, Optional

class Solution:
    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        ans: List[float] = []
        q = deque([root])
        while q:
            sz = len(q)
            total = 0
            for _ in range(sz):
                cur = q.popleft()
                total += cur.val
                if cur.left:
                    q.append(cur.left)
                if cur.right:
                    q.append(cur.right)
            ans.append(total / sz)
        return ans

var averageOfLevels = function(root) {
    const ans = [];
    let q = [root];
    while (q.length > 0) {
        const sz = q.length;
        let sum = 0;
        const next = [];
        for (let i = 0; i < sz; i++) {
            const cur = q[i];
            sum += cur.val;
            if (cur.left) next.push(cur.left);
            if (cur.right) next.push(cur.right);
        }
        ans.push(sum / sz);
        q = next;
    }
    return ans;
};

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> ans = new ArrayList<>();
        Deque<TreeNode> q = new ArrayDeque<>();
        q.offer(root);
        while (!q.isEmpty()) {
            int sz = q.size();
            long sum = 0;
            for (int i = 0; i < sz; i++) {
                TreeNode cur = q.poll();
                sum += cur.val;
                if (cur.left != null) q.offer(cur.left);
                if (cur.right != null) q.offer(cur.right);
            }
            ans.add((double) sum / sz);
        }
        return ans;
    }
}

function averageOfLevels(root: TreeNode | null): number[] {
    const ans: number[] = [];
    let q: TreeNode[] = root ? [root] : [];
    while (q.length > 0) {
        const sz = q.length;
        let sum = 0;
        const next: TreeNode[] = [];
        for (let i = 0; i < sz; i++) {
            const cur = q[i];
            sum += cur.val;
            if (cur.left) next.push(cur.left);
            if (cur.right) next.push(cur.right);
        }
        ans.push(sum / sz);
        q = next;
    }
    return ans;
}