一【题目类别】

• 二叉树

二【题目难度】

• 简单

三【题目编号】

• 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,10^4]范围内$
• $-2^{31}<=Node.val<=2^{31}-1$

七【解题思路】

• 本题思路很简单，看到层相关的二叉树的题目，就应该立马想到BFS（广度优先遍历）
• 所以手写一个队列，将每层的值依次求平均值放到结果数组中即可，难度不大
• 要注意类型转换，求平均值的时候要使用double类型，否则会损失精度

八【时间频度】

• 时间复杂度：$O(n)$，其中$n$为树的结点个数
• 空间复杂度：$O(n)$，其中$n$为树的结点个数

九【代码实现】

1. Java语言版

package Tree;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class p637_LevelAverageOfBinaryTrees {

    int val;
    p637_LevelAverageOfBinaryTrees left;
    p637_LevelAverageOfBinaryTrees right;

    public p637_LevelAverageOfBinaryTrees() {
    }

    public p637_LevelAverageOfBinaryTrees(int val) {
        this.val = val;
    }

    public p637_LevelAverageOfBinaryTrees(int val, p637_LevelAverageOfBinaryTrees left, p637_LevelAverageOfBinaryTrees right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }

    public static void main(String[] args) {
        p637_LevelAverageOfBinaryTrees root = new p637_LevelAverageOfBinaryTrees(3);
        p637_LevelAverageOfBinaryTrees left = new p637_LevelAverageOfBinaryTrees(9);
        p637_LevelAverageOfBinaryTrees right = new p637_LevelAverageOfBinaryTrees(20);
        p637_LevelAverageOfBinaryTrees right1 = new p637_LevelAverageOfBinaryTrees(15);
        p637_LevelAverageOfBinaryTrees right2 = new p637_LevelAverageOfBinaryTrees(7);
        root.left = left;
        root.right = right;
        right.left = right1;
        right.right = right2;
        List<Double> res = averageOfLevels(root);
        System.out.println("res = " + res);
    }

    public static List<Double> averageOfLevels(p637_LevelAverageOfBinaryTrees root) {
        List<Double> res = new ArrayList<>();
        Queue<p637_LevelAverageOfBinaryTrees> queue = new LinkedList<>();
        queue.add(root);
        while (queue.size() != 0) {
            double sum = 0;
            int len = queue.size();
            for (int i = 0; i < len; i++) {
                p637_LevelAverageOfBinaryTrees temp = queue.poll();
                sum += temp.val;
                if (temp.left != null) {
                    queue.add(temp.left);
                }
                if (temp.right != null) {
                    queue.add(temp.right);
                }
            }
            res.add(sum / len);
        }
        return res;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

2. C语言版

#include

struct TreeNode
{
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
};

double* averageOfLevels(struct TreeNode* root, int* returnSize)
{
	double* res = (double*)malloc(sizeof(double) * 10001);
	int index = 0;
	struct TreeNode** queue = (struct TreeNode**)malloc(sizeof(struct TreeNode*) * 10001);
	int front = 0;
	int rear = 0;
	queue[rear++] = root;
	while (front != rear)
	{
		double sum = 0;
		int size = (rear - front + 10001) % 10001;
		for (int i = 0; i < size; i++)
		{
			struct TreeNode* temp = queue[front++];
			sum += temp->val;
			if (temp->left != NULL)
			{
				queue[rear++] = temp->left;
			}
			if (temp->right != NULL)
			{
				queue[rear++] = temp->right;
			}
		}
		res[index++] = sum / size;
	}
	*returnSize = index;
	return res;
}

/*主函数省略*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

十【提交结果】

1. Java语言版
   

2. C语言版