How to Compute Average of Levels in Binary Tree?

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        if (root == NULL) {
            return {};
        }
        queue<pair<TreeNode*, int>> Q;
        Q.push(make_pair(root, 0));
        unordered_map<int, int> counter;
        vector<double> result;
        while (!Q.empty()) {
            auto p = Q.front();
            Q.pop();
            auto depth = p.second;
            if (counter.find(depth) == counter.end()) {
                counter[depth] = 1; // first element in this level
            } else {
                counter[depth] ++;
            }
            if (result.size() <= depth) {
                result.push_back(p.first->val);
            } else {
                // update the average number
                result[depth] = (result[depth] * (counter[depth] - 1) + p.first->val) / counter[depth];
            }
            if (p.first->left) {
                Q.push(make_pair(p.first->left, depth + 1));
            }
            if (p.first->right) {
                Q.push(make_pair(p.first->right, depth + 1));
            }            
        }
        return result;
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        if (root == NULL) {
            return {};
        }
        map<int, vector<int>> data;  // level and their associate values
        vector<double> r;
        queue<pair<TreeNode*, int>> q;
        q.push(make_pair(root, 1));
        while (q.size() > 0) {
            auto p = q.front();
            q.pop();
            if (data.find(p.second) == data.end()) { 
                data[p.second] = { p.first->val };
            } else {
                data[p.second].push_back(p.first->val);
            }
            if (p.first->left != NULL) {
                q.push(make_pair(p.first->left, p.second + 1));
            }
            if (p.first->right != NULL) {
                q.push(make_pair(p.first->right, p.second + 1));
            }
        }
        for (const auto &n: data) {
            vector<int> x = n.second;
            int64_t sum = 0;
            for (int i = 0; i < x.size(); ++ i) {
                sum += x[i];
            }
            r.push_back(sum * 1.0 / x.size());
        }
        return r;
    }
};

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        if (root == nullptr) return {};
        queue<TreeNode*> Q;
        Q.push(root);
        vector<double> r;
        while (!Q.empty()) {
            int sz = Q.size();
            double sum = 0;
            for (size_t i = 0; i < sz; ++ i) { // expanding next level's nodes
                auto p = Q.front();
                Q.pop();
                if (p->left) {
                    Q.push(p->left);
                }
                if (p->right) {
                    Q.push(p->right);
                }
                sum += p->val;
            }
            r.push_back(sum / sz);
        }
        return r;
    }
};