leetcode 637.二叉树的层平均值

题目：https://leetcode-cn.com/problems/average-of-levels-in-binary-tree/

思路一：广度优先搜索

1. 定义一个数组，用于保存每层的平均值，定义一个队列，用于存储 每层的节点，

2. 将根节点入队列

3. 如果队列不为空，就循环

4. 用一个变量保存当前队列的大小（每层的节点数）

5. 将队首出队列，将出队列的结点的值进行累加，将每层的节点遍结束后，算平均值，得到的平均值入数组

6. 循环结束后，返回数组

vector<double> averageOfLevels(TreeNode* root) {


        vector<double> vec;
        queue<TreeNode*>que;
        if(root==NULL)
        return vec;
        que.push(root);
        while(!que.empty())
        {
            int len=que.size();
            double sum=0;
            double ave=0;
            for(int i=0;i<len;i++)
            {
                TreeNode*node=que.front();
                que.pop();
                sum+=node->val;
                if(node->left)
                  que.push(node->left);
                if(node->right)
                  que.push(node->right);
            }
            ave=double(sum )/len;
            vec.push_back(ave);
        }
       return vec;
    }

思路二：深度优先搜索法
分析：
需要两个数组： sums用于保存每层节点的和， counts 用于保存每一层的节点数，搜索过程需要记录当前结点的层数，如果访问到的节点在第 ii 层，则将 counts[i] 的值加 11，并将该节点的值加到 sums[i]中
步骤：

1. 定义两个函数：dfs用于深度搜索树的节点，averageOfLevels（）求每层的平均值

2. dfs采用递归的思想

• 函数的参数：节点，层数，两个数组，一个用于保存每层结点的和，一个用于保存每层的节点数

• 函数返回值：无

• 递归结束的条件： 节点为空时结束

• 单层逻辑;

  (1) 判断节点是否为空，为空就返回；
  (2) 如果当前结点的层数小于数组的长度（说明不是第一次访问当前层数的节点），将当前层的节点数+1，将访问过的当前层的节点和加上当前节点的值求和放入数组，如果不小于（说明第一次访问当前层），就将结点的值入数组，节点数为1入数组，
  (3)遍历下一层的左子树；
  (4)遍历下一层的右子树

3. averageOfLevels（）函数实现求平均，dfs()函数遍历整棵树，实现将每层结点的和放入到数组中，每层的节点数放入到数组中

• 定义两个数组，用于保存每层的节点数和每层节点数之和，定义一个变量，用于记录当前节点所在的层数，定义一个数组，用于存储每层结点的平均 值

• 调用dfs函数

• 定义一个变量，用于记录结点的层数（结点的层数和数组的宽度）

• 循环遍历数组的每个值，对每个值进行 vec[i] / count[i]的计算，求得每 层的平均值，保存数组

• 循环结束后返回函数值

void dfs(TreeNode* root, int level,vector<double>&vec,vector<int> &count)
{
       if (root == NULL)
              return;
       if (level< vec.size())
       {
              count[level] += 1;
              vec[level] += root->val;
       }
       else {
              count.push_back(1);
              vec.push_back(1.0*root->val);
       }
       dfs(root->left, level + 1, vec, count);
       dfs(root->right, level + 1, vec, count);
      
               
}
vector<double> averageOfLevels(TreeNode* root)
{
       vector<double>vec;
       vector<int> count;
       int level = 0;
       vector<double>ave;
       if (root == NULL)
              return vec;
       dfs(root, level, vec, count);
       int len = vec.size();
       for (int i = 0; i < len; i++)
       {
              double res = vec[i] / count[i];
              ave.push_back(res);
       }
       return ave;
}