给定二叉树中子树值的最大平均值

给定一个由N 个节点组成的二叉树，任务是找到任何子树节点值的最大平均值。

例子：

Input:                   5
                            /   \
                          3     8 
Output: 8
Explanation:
Average of values of subtree of node 5 = (5 + 3 + 8) / 3 = 5.33
Average of values of subtree of node 3 = 3 / 1 = 3
Average of values of subtree of node 8 = 8 / 1 = 8.

Input:                 20
                        /       \
                    12        18
                   /   \       /  \
                 11    3    15  8 
Output: 15
Explanation: Average of values of subtree of node 15 is the maximum.

方法：给定的问题类似于寻找一棵树中最大的子树和。这个想法是使用 DFS 遍历技术。请按照以下步骤解决问题：

• 初始化一个变量， ans用0来存储结果。
• 定义一个函数maxAverage()用于 DFS 遍历。
  • 初始化两个变量， sum存储其子树的总和， count存储其子树中的节点数，其中0 。
  • 遍历当前节点的子节点并为其子节点调用maxAverage() ，并按子节点子树的总和递增sum并按子节点中的总节点计数
  • 按当前节点的值增加总和 并按1计数。
  • 取ans和sum/count的最大值并将其存储在ans 中。
  • 最后，返回一对{sum, count} 。
• 将获得的最大平均值打印为ans 。

C++

// C++ program for the above approach
#include 
using namespace std;
 
struct TreeNode
{
    int val;
     
    vector children;
     
    TreeNode(int v)
    {
        val = v;
    }
};
 
// Stores the result
double ans = 0.0;
 
// Function for finding maximum
// subtree average
vector MaxAverage(TreeNode* root)
{
     
    // Checks if current node is not
    // NULL and doesn't have any children
    if (root != NULL && root->children.size() == 0)
    {
        ans = max(ans, (root->val) * (1.0));
        return {root->val, 1};
    }
 
    // Stores sum of its subtree in index 0
    // and count number of nodes in index 1
    vector childResult (2);
 
    // Traverse all children of the current node
    for(TreeNode *child : root->children)
    {
         
        // Recursively calculate max average
        // of subtrees among its children
        vector childTotal = MaxAverage(child);
 
        // Increment sum by sum
        // of its child's subtree
        childResult[0]     = childResult[0] + childTotal[0];
 
        // Increment number of nodes
        // by its child's node
        childResult[1] = childResult[1] + childTotal[1];
    }
 
    // Increment sum by current node's value
    int sum = childResult[0] + root->val;
 
    // Increment number of
    // nodes by one
    int count = childResult[1] + 1;
 
    // Take maximum of ans and
    // current node's average
    ans = max(ans, sum / count * 1.0);
 
    // Finally return pair of {sum, count}
    return{sum, count};
}
 
// Driver Code
int main()
{
     
    // Given tree
    TreeNode *root = new TreeNode(20);
    TreeNode *left = new TreeNode(12);
    TreeNode *right = new TreeNode(18);
     
    root->children.push_back(left);
    root->children.push_back(right);
     
    left->children.push_back(new TreeNode(11));
    left->children.push_back(new TreeNode(3));
    right->children.push_back(new TreeNode(15));
    right->children.push_back(new TreeNode(8));
 
    // Function call
    MaxAverage(root);
 
    // Print answer
    printf("%0.1f\n", ans);
}
 
// This code is contributed by mohit kumar 29

Java

// Java program for the above approach
 
import java.util.*;
 
// Structure of the Tree node
class TreeNode {
    public int val;
    public List children;
 
    public TreeNode(int v)
    {
        val = v;
        children = new ArrayList();
    }
}
 
class GFG {
 
    // Stores the result
    static double ans = 0.0;
 
    // Function for finding maximum
    // subtree average
    public static double[] MaxAverage(
        TreeNode root)
    {
 
        // Checks if current node is not
        // null and doesn't have any children
        if (root.children != null
            && root.children.size() == 0) {
            ans = Math.max(ans, root.val);
            return new double[] { root.val, 1 };
        }
 
        // Stores sum of its subtree in index 0
        // and count number of nodes in index 1
        double[] childResult = new double[2];
 
        // Traverse all children of the current node
        for (TreeNode child : root.children) {
 
            // Recursively calculate max average
            // of subtrees among its children
            double[] childTotal
                = MaxAverage(child);
 
            // Increment sum by sum
            // of its child's subtree
            childResult[0]
                = childResult[0] + childTotal[0];
 
            // Increment number of nodes
            // by its child's node
            childResult[1]
                = childResult[1] + childTotal[1];
        }
 
        // Increment sum by current node's value
        double sum = childResult[0] + root.val;
 
        // Increment number of
        // nodes by one
        double count = childResult[1] + 1;
 
        // Take maximum of ans and
        // current node's average
        ans = Math.max(ans, sum / count);
 
        // Finally return pair of {sum, count}
        return new double[] { sum, count };
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // Given tree
        TreeNode root = new TreeNode(20);
        TreeNode left = new TreeNode(12);
        TreeNode right = new TreeNode(18);
        root.children.add(left);
        root.children.add(right);
        left.children.add(new TreeNode(11));
        left.children.add(new TreeNode(3));
        right.children.add(new TreeNode(15));
        right.children.add(new TreeNode(8));
 
        // Function call
        MaxAverage(root);
 
        // Print answer
        System.out.println(ans);
    }
}

Python3

# Python3 program for the above approach
 
# Stores the result
ans = 0.0
 
class TreeNode:
     
    def __init__ (self, val):
       
        self.val = val
        self.children = []
 
# Function for finding maximum
# subtree average
def MaxAverage(root):
     
    global ans
     
    # Checks if current node is not
    # None and doesn't have any children
    if (root != None and len(root.children) == 0):
        ans = max(ans, (root.val))
        return [root.val, 1]
 
    # Stores sum of its subtree in index 0
    # and count number of nodes in index 1
    childResult = [0 for i in range(2)]
 
    # Traverse all children of the current node
    for child in root.children:
         
        # Recursively calculate max average
        # of subtrees among its children
        childTotal = MaxAverage(child)
 
        # Increment sum by sum
        # of its child's subtree
        childResult[0] = childResult[0] + childTotal[0]
 
        # Increment number of nodes
        # by its child's node
        childResult[1] = childResult[1] + childTotal[1]
 
    # Increment sum by current node's value
    sum = childResult[0] + root.val
 
    # Increment number of
    # nodes by one
    count = childResult[1] + 1
 
    # Take maximum of ans and
    # current node's average
    ans = max(ans, sum / count)
 
    # Finally return pair of {sum, count}
    return [sum, count]
 
# Driver Code
if __name__ == '__main__':
     
    # Given tree
    root =  TreeNode(20)
    left =  TreeNode(12)
    right =  TreeNode(18)
     
    root.children.append(left)
    root.children.append(right)
     
    left.children.append(TreeNode(11))
    left.children.append(TreeNode(3))
    right.children.append(TreeNode(15))
    right.children.append(TreeNode(8))
 
    # Function call
    MaxAverage(root)
 
    # Print answer
    print(ans * 1.0)
 
# This code is contributed by ipg2016107

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
using System.Globalization;
public class TreeNode
{
  public int val;
  public List children;
 
  public TreeNode(int v)
  {
    val = v;
    children = new List();
  }
}
 
public class GFG
{
 
  // Stores the result
  static double ans = 0.0;
 
  // Function for finding maximum
  // subtree average
  public static double[] MaxAverage( TreeNode root)
  {
 
    // Checks if current node is not
    // null and doesn't have any children
    if (root.children != null
        && root.children.Count == 0)
    {
      ans = Math.Max(ans, root.val);
      return new double[] { root.val, 1 };
    }
 
    // Stores sum of its subtree in index 0
    // and count number of nodes in index 1
    double[] childResult = new double[2];
 
    // Traverse all children of the current node
    foreach (TreeNode child in root.children)
    {
 
      // Recursively calculate max average
      // of subtrees among its children
      double[] childTotal
        = MaxAverage(child);
 
      // Increment sum by sum
      // of its child's subtree
      childResult[0]
        = childResult[0] + childTotal[0];
 
      // Increment number of nodes
      // by its child's node
      childResult[1]
        = childResult[1] + childTotal[1];
    }
 
    // Increment sum by current node's value
    double sum = childResult[0] + root.val;
 
    // Increment number of
    // nodes by one
    double count = childResult[1] + 1;
 
    // Take maximum of ans and
    // current node's average
    ans = Math.Max(ans, sum / count);
 
    // Finally return pair of {sum, count}
    return new double[] { sum, count };
  }
 
  // Driver code
  static public void Main ()
  {
    // Given tree
    TreeNode root = new TreeNode(20);
    TreeNode left = new TreeNode(12);
    TreeNode right = new TreeNode(18);
    root.children.Add(left);
    root.children.Add(right);
    left.children.Add(new TreeNode(11));
    left.children.Add(new TreeNode(3));
    right.children.Add(new TreeNode(15));
    right.children.Add(new TreeNode(8));
 
    // Function call
    MaxAverage(root);
 
    // Print answer
    NumberFormatInfo setPrecision = new NumberFormatInfo();
 
    setPrecision.NumberDecimalDigits = 1;
 
    Console.WriteLine(ans.ToString("N", setPrecision));
  }
}
 
// This code is contributed by rag2127

Javascript

// Javascript program for the above approach
 
// Structure of the Tree node
class TreeNode
{
    constructor(v)
    {
        this.val = v;
        this.children = [];
    }
}
 
    // Stores the result
    let ans = 0.0;
     
    // Function for finding maximum
    // subtree average
    function MaxAverage(root)
    {
        // Checks if current node is not
        // null and doesn't have any children
        if (root.children != null
            && root.children.length == 0)
        {
            ans = Math.max(ans, root.val);
            return  [ root.val, 1 ];
        }
  
        // Stores sum of its subtree in index 0
        // and count number of nodes in index 1
        let childResult = new Array(2);
        for(let i=0;i<childResult.length;i++)
        {
            childResult[i] = 0;
        }
  
        // Traverse all children of the current node
        for (let child = 0; child < root.children.length; child++)
        {
  
            // Recursively calculate max average
            // of subtrees among its children
            let childTotal
                = MaxAverage(root.children[child]);
  
            // Increment sum by sum
            // of its child's subtree
            childResult[0]
                = childResult[0] + childTotal[0];
  
            // Increment number of nodes
            // by its child's node
            childResult[1]
                = childResult[1] + childTotal[1];
        }
  
        // Increment sum by current node's value
        let sum = childResult[0] + root.val;
  
        // Increment number of
        // nodes by one
        let count = childResult[1] + 1;
  
        // Take maximum of ans and
        // current node's average       
        ans = Math.max(ans, sum / count);
  
        // Finally return pair of {sum, count}
        return [ sum, count ];
    }
     
    // Driver Code
     
    // Given tree
        let root = new TreeNode(20);
        let left = new TreeNode(12);
        let right = new TreeNode(18);
        root.children.push(left);
        root.children.push(right);
        left.children.push(new TreeNode(11));
        left.children.push(new TreeNode(3));
        right.children.push(new TreeNode(15));
        right.children.push(new TreeNode(8));
  
        // Function call
        MaxAverage(root);
  
        // Print answer
        document.write(ans.toFixed(1));
     
// This code is contributed by unknown2108

输出：

15.0

时间复杂度： O(N)
辅助空间： O(N)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live