[LeetCode] 637. Average of Levels in Binary Tree

原题链接： https://leetcode.com/problems/average-of-levels-in-binary-tree/

1. 题目介绍

Given a non-empty binary tree, return the average value of the nodes on each level in the form of an array.
给出一个非空的二叉树，返回每一层节点val值的平均值。

Example 1:
Input:

Output: [3, 14.5, 11]
Explanation:
The average value of nodes on level 0 is 3, on level 1 is 14.5, and on level 2 is 11. Hence return [3, 14.5, 11].
第0层的平均值是3，第1层的平均值是（9+20）/2 = 14.5，第2层的是（15+7）/2 = 11.
因此返回 [3, 14.5, 11].
Note:
The range of node’s value is in the range of 32-bit signed integer.
节点值的范围是32位的有符号整数。

2. 解题思路

本题是 102. Binary Tree Level Order Traversal 的拓展题，建议读者在做本题之前先去做一下 102. Binary Tree Level Order Traversal . 和本题类似的题目还有 429. N-ary Tree Level Order Traversal

方法1 队列 + 标记

如何区分不同的层是本题的一个难点，其中一种方式是使用队列+标记的方法。
每次将一层的所有节点都放入队列之后，就在队列尾部插入一个null节点，用于标记一层的结束。

使用 sum 记录同一层的节点 val 值之和，使用 Count 记录同一层的节点个数。

a) 当从队列前方取出元素时，如果取出的元素是节点，那么就将 sum 加上该节点的 val 值 ，Count 加一，并且将左右子节点都放入队列。

b) 当从队列前方取出的元素是 null 时，说明已经遍历完一层了，此时 sum 就是这一层所有节点的 val 值的总和，将sum / Count 存放入总的结果 ans 里。之后将 Count 和 sum 清空。此时的队列中，队列的尾部已经存放好了新的一层的节点了，需要在队列最后面再补一个 null 标记这个新的一层的结束。

实现代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> ans = new ArrayList<>();
        if(root == null){
            return ans;
        }
        
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        queue.add(null);
        
        Double sum = 0.0;//同一层的节点 val 值之和
        Double Count = 0.0;//同一层的节点个数
        
        while(queue.isEmpty() == false){
            TreeNode t = queue.remove();
            if(t == null){
                ans.add(sum / Count);
                sum = 0.0;
                Count = 0.0;
                if(queue.isEmpty() == false){
                    queue.add(null);
                }
            }else{
                sum += t.val;
                Count++;
                if(t.left != null){
                    queue.add(t.left);
                }
                if(t.right != null){
                    queue.add(t.right);
                }
            }
        }
        return ans;
    }
}

方法2 队列 + 计数

如果使用队列，还会有一个规律：
每当从队列前部移出去一层以后，队列中剩余节点的个数就是树的下一层的节点数。
因此可以利用这个规律来对树进行分层。

实现代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> ans = new ArrayList<>();
        if(root == null){
            return ans;
        }
        
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
    
        while(queue.isEmpty() == false){
            int N = queue.size();
            int Count = 0;
            Double sum = 0.0;
            while( Count < N ){
                TreeNode t = queue.remove();
                Count++;
                sum += t.val;
                if(t.left != null){
                    queue.add(t.left);
                }
                if(t.right != null){
                    queue.add(t.right);
                }
            }
            ans.add(sum / Count );
        }
        return ans;
    }
}

方法3 深度优先搜索

虽然，逐层遍历通常采用的是广度优先搜索的方法，但是使用深度优先搜索同样可以解决本题。
如果使用深度优先搜索的方法，可以先找出每层全部的节点，存放在 List<List< Double >> Ave 中，然后再计算平均值放入最终的结果 List< Double > ans中。

注意，java中 Double和double是不同的，
double是基本数据类型，没有方法，只创建引用
Double是一个类，有自己的属性和方法，创建对象。

实现代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> ans = new LinkedList<>();
        if(root == null){
            return ans;
        }
        
        List<List<Double>> Ave = new LinkedList<>();
        //Ave用于存储每层的val值，最后需要利用Ave求每层平均值
        helper(root , Ave , 1);
        //helper用于填充Ave
        
        //计算平均值放入ans
        for(List<Double> i : Ave){
            double Sum = 0;
            for(Double j : i){
                Sum += j;
            }
            ans.add(Sum / i.size());
        }
        return ans;
    }
    
    public void helper(TreeNode root, List<List<Double>> Ave, int depth ){
        if(root == null){
            return;
        }
        if(depth > Ave.size()){
            List<Double> temp = new ArrayList<>();
            Ave.add(temp);
        }
       
        Ave.get(depth-1).add( (double)root.val );
        
        helper(root.left , Ave , depth+1);
        helper(root.right , Ave , depth+1);
    }
}