每日一题总结二叉树的层平均值

给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。

示例 1：

输入：
3
/
9 20
/
15 7
输出：[3, 14.5, 11]
解释：
第 0 层的平均值是 3 , 第1层是 14.5 , 第2层是 11 。因此返回 [3, 14.5, 11] 。

这道题的实质是考察层序遍历，深度优先搜索和广度优先搜索
对深度优先而言，需要维护两个序列，一个用来保存节点数，一个用来保存节点之和，最后除。
对于深度优先而言
DSF函数需要四个参数，根节点，当前层数，节点数队列，节点队列
DFS（root ，0，count,sum）;

/**
 * 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:

    void dfs(TreeNode* root,int level,vector<double> count,vector<int> sum)
    {
        if(root == nullptr)
        return ;
        if(level < sum.size()){
            sum[level] += root->val ;
            count[level]++;
        }
        if(level >= sum.size()){
             sum.push_back( root->val) ;
            count.push_back(1);
        }

        dfs(root->left,level+1,count,sum);
        dfs(root->right,level+1,count,sum);

        
    }

    vector<double> averageOfLevels(TreeNode* root) {
        vector<int> sum;
        vector<double> count;
        dfs(root,0,count,sum);
        vector<double> ans;
        for(int i=0;i<sum.size();i++)
        {
            ans.push_back(sum[i]/count[i]);
        }
        return ans;}
};

上面是开始的错误代码，错误原因是传参时使用的是形参而不是引用，因此，无法改变传入的数组,其次需要主义使用vector会有数据溢出的风险，正确做法是改成vector类型。
正确代码

/**
 * 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:

    void dfs(TreeNode* root,int level,vector<int>& count,vector<double>& sum)
    {
        if(root == nullptr)
        return ;
        if(level < sum.size()){
            sum[level] += root->val ;
            count[level]++;
        }
        if(level >= sum.size()){
             sum.push_back( root->val) ;
            count.push_back(1);
        }

        dfs(root->left,level+1,count,sum);
        dfs(root->right,level+1,count,sum);

        
    }

    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> sum;
        vector<int> count;
        dfs(root,0,count,sum);
        vector<double> ans;
        for(int i=0;i<sum.size();i++)
        {
            ans.push_back(sum[i]/count[i]);
        }
        return ans;}
};

第二种方法则是广度优先方法

根节点搜索，遍历同义词的全部节点，并且计算和，最后计算平均值，和层次遍历类似具体过程如下。

1. 初始，将根节点加入队列中
2. 每一轮遍历时，将队列所有节点去除，计算，再将这些节点的字节点加入对垒，重复上述操作直到队列为空，遍历结束。

/**
 * 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) {
        vector<double> sum;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            double add = 0;
            int j = que.size();
            for(int i=0;i<j ;i++)
            {
                 add+= que.front()->val;
            TreeNode* left = que.front()->left;
            TreeNode* right = que.front()->right;
            que.pop();
            if(left != nullptr)
            que.push(left);
            if(right != nullptr)
            que.push(right);
            }
          sum.push_back(add/j);
        }
        return sum;
    }
};