Leetcode每日一题(20200912)

今日题目

T637 二叉树的层平均值(简单，搜索)

题目描述

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

示例 1：

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

提示：节点值的范围在32位有符号整数范围内。

标签

深度优先搜索，广度优先搜索

解析

方法一：广度优先搜索

“每层节点的平均值”，看到这里我们应该能够想到，这道题适合使用按层次遍历的方法（也就是广度优先搜索）。广度优先搜索遍历二叉树的方法，之前已经讲过很多遍，这里不再赘述。

方法二：深度优先搜索

这道题同样可以使用深度优先搜索的方法解题。需要注意的是，使用深度优先搜索方法时，必须先遍历完整棵二叉树后，统计出每层的节点数和节点总和，然后再求出平均值。

Python解法

#bfs
class Solution:
    def averageOfLevels(self, root: TreeNode) -> List[float]:
        avg = []
        q = collections.deque([root])
        while q:
            sum = 0
            size = len(q)
            for i in range(size):
                node = q.popleft()
                sum += node.val
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            avg.append(sum / size)
        return avg

#dfs
class Solution:
    def averageOfLevels(self, root: TreeNode) -> List[float]:
        sum = []
        cnt = []

        def dfs(root, depth):
            if not root:
                return
            if (depth >= len(sum)):
                sum.append(0)
                cnt.append(0)
            sum[depth] += root.val
            cnt[depth] += 1
            dfs(root.left, depth + 1)
            dfs(root.right, depth + 1)

        dfs(root, 0)
        avg = [sum[i] / cnt[i] for i in range(len(sum))]
        return avg

C++解法

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

//dfs
class Solution
{
public:
    vector<double> sum;
    vector<int> cnt;
    void dfs(TreeNode *root, int depth)
    {
        if (root == nullptr)
        {
            return;
        }
        if (depth == sum.size())
        {
            sum.push_back(0);
            cnt.push_back(0);
        }
        sum[depth] += root->val;
        cnt[depth]++;
        dfs(root->left, depth + 1);
        dfs(root->right, depth + 1);
    }
    vector<double> averageOfLevels(TreeNode *root)
    {
        dfs(root, 0);
        vector<double> avg;
        for (int i = 0; i < sum.size(); ++i)
        {
            avg.push_back(sum[i] / cnt[i]);
        }
        return avg;
    }
};