一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第9天，点击查看活动详情。

一、题目描述

原文链接：637. 二叉树的层平均值
具体描述： 给定一个非空二叉树的根节点 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, 104] 范围内
• -2^31 <= Node.val <= 2^31 - 1

二、思路分析

其实就是二叉数的层次遍历，只不过不需要存储每一层的值，只需要把每一层的值求平均数就可以啦！

顺便我们复习二叉数的层次遍历思路：

• 定义一个队列来进行存储二叉数，首次把root添加到树当中
• 每次根据根据队列的当前长度来遍历队列，存储结果，顺待把当前节点的左右孩子添加到队列当中
• 循环第二步，知道队列为空！

三、AC代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> result = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if (root != null) queue.offer(root);
        while (queue.isEmpty() == false){
            int levelSize = queue.size();
            Double levelSum = new Double(0);
            for (int i = 0; i < levelSize; i++){
                TreeNode tmpNode = queue.poll();
                levelSum += tmpNode.val;
                if (tmpNode.left != null) queue.offer(tmpNode.left);
                if (tmpNode.right != null) queue.offer(tmpNode.right);
            }
            result.add(levelSum / levelSize);
        }
        return result;
    }
}

四、总结

• 二叉数的层次遍历

五、巩固提升

429. N 叉树的层序遍历（把左右子数换成List集合就可以啦！！！）

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> result = new ArrayList<>();
        Queue<Node> queue = new LinkedList<>();
        if (root != null) queue.offer(root);

        while (queue.isEmpty() == false){
            List<Integer> tmpList = new ArrayList<>();
            int len = queue.size();
            while (len > 0){
                Node tmpNode = queue.poll();
                tmpList.add(tmpNode.val);
                for (int i = 0; i < tmpNode.children.size(); i++){
                    queue.offer(tmpNode.children.get(i));
                }
                len--;
            }
            result.add(tmpList);
        }

        return result;
    }
}

感谢大家的阅读，我是Alson_Code，一个喜欢把简单问题复杂化，把复杂问题简单化的程序猿！ ❤