LeetCode 面试经典 150_二叉树层次遍历_二叉树的层平均值（82_637_C++_简单）

题目描述：

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

输入输出样例：

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。

因此返回 [3, 14.5, 11] 。

示例 2：

输入：root = [3,9,20,15,7]
输出：[3.00000,14.50000,11.00000]

提示：

树中节点数量在 [1, 10⁴] 范围内

-2³¹ <= Node.val <= 2³¹ - 1

题解：

解题思路：

思路一（BFS）：

1、采用层次遍历的思想，计算每层结点值的总和 和结点个数 ，再计算每层的平均值。采用层次遍历的思想，当一层遍历完，队列中的元素为下一层的全部结点 。

2、复杂度分析：

① 时间复杂度：O(n)，其中 n 是二叉树中的节点个数。遍历了一遍二叉树。

② 空间复杂度：O(n)，其中 n 是二叉树中的节点个数。空间复杂度取决于队列开销，队列中的节点个数不会超过 n。

代码实现

代码实现（思路一（BFS））：

cpp 复制代码

class Solution{
public:
    vector<double> averageOfLevels(TreeNode *root){
        // 创建一个队列，用于进行广度优先遍历 (BFS)
        queue<TreeNode*> Q;
        // 将根节点加入队列
        Q.push(root);
        // 存储每一层的平均值
        vector<double> ans;
        
        // 当队列不为空时，继续遍历
        while (!Q.empty()){
            // 当前层的节点值总和
            double sum = 0;
            // 当前层的节点个数
            int size = Q.size();
            
            // 遍历当前层的所有节点
            for (int i = 0; i < size; i++){
                // 获取队列中的第一个节点
                TreeNode *node = Q.front();
                // 将该节点的值累加到 sum
                sum += node->val;
                // 弹出队列中的该节点
                Q.pop();

                // 如果当前节点有左子树，将左子树加入队列
                if (node->left != nullptr) Q.push(node->left);
                // 如果当前节点有右子树，将右子树加入队列
                if (node->right != nullptr) Q.push(node->right);
            }
            
            // 计算当前层的平均值，并将其加入结果数组
            ans.push_back(sum / size);
        }
        
        // 返回存储所有层平均值的数组
        return ans;
    }
};

以思路一为例进行调试

cpp 复制代码

#include<iostream>
#include<vector>
#include<queue>
using namespace std;

struct TreeNode{
    int val;
    TreeNode *left;
    TreeNode *right;
    
    TreeNode():val(0),left(nullptr),right(nullptr){}
    TreeNode(int x):val(x),left(nullptr),right(nullptr){}
    TreeNode(int x,TreeNode *left,TreeNode *right):val(x),left(left),right(right){}
};

TreeNode *createTree(vector<int> nums){
    if (nums.empty()){
        return nullptr;
    }
    TreeNode *root=new TreeNode(nums[0]);
    queue<TreeNode *> Q;
    Q.push(root);

    int i=1;
    while (i<nums.size()){
        TreeNode *node = Q.front();
        Q.pop();
        if (i<nums.size()&&nums[i]!=-1){
            node->left=new TreeNode(nums[i]);
            Q.push(node->left);
        }
        i++;

        if (i<nums.size()&&nums[i]!=-1){
            node->right=new TreeNode(nums[i]);
            Q.push(node->right);
        }
        i++;
    }
    return root;
}

class Solution{
public:
    vector<double> averageOfLevels(TreeNode *root){
        // 创建一个队列，用于进行广度优先遍历 (BFS)
        queue<TreeNode*> Q;
        // 将根节点加入队列
        Q.push(root);
        // 存储每一层的平均值
        vector<double> ans;
        
        // 当队列不为空时，继续遍历
        while (!Q.empty()){
            // 当前层的节点值总和
            double sum = 0;
            // 当前层的节点个数
            int size = Q.size();
            
            // 遍历当前层的所有节点
            for (int i = 0; i < size; i++){
                // 获取队列中的第一个节点
                TreeNode *node = Q.front();
                // 将该节点的值累加到 sum
                sum += node->val;
                // 弹出队列中的该节点
                Q.pop();

                // 如果当前节点有左子树，将左子树加入队列
                if (node->left != nullptr) Q.push(node->left);
                // 如果当前节点有右子树，将右子树加入队列
                if (node->right != nullptr) Q.push(node->right);
            }
            
            // 计算当前层的平均值，并将其加入结果数组
            ans.push_back(sum / size);
        }
        
        // 返回存储所有层平均值的数组
        return ans;
    }
};



int main(int argc, char const *argv[])
{

    vector<int> nums = {3,9,20,-1,-1,15,7};
    TreeNode *root= createTree(nums);
    Solution s;
    vector<double> ans= s.averageOfLevels(root);
    for(auto &i:ans){
        cout<<i<<" ";
    }
    return 0;
}

LeetCode 面试经典 150_二叉树层次遍历_二叉树的层平均值（82_637)原题链接

欢迎大家和我沟通交流(✿◠‿◠)