Maximum Average Subtree - Practice Coding Problems

Maximum Average Subtree - Problem

Find the Maximum Average Subtree

Imagine you're analyzing different departments in a company, where each department is represented as a node in a hierarchical tree structure. Each department has a performance score, and you want to find which department (including all its sub-departments) has the highest average performance.

Given the root of a binary tree where each node contains a numerical value, your task is to find the maximum average value among all possible subtrees. A subtree consists of any node plus all of its descendants (children, grandchildren, etc.).

The average value of a subtree is calculated as: sum of all node values / number of nodes

Goal: Return the maximum average value found among all subtrees.
Note: Answers within 10^-5 of the actual answer will be accepted.

Input & Output

example_1.py — Basic Tree

$ Input: root = [5,6,1]

› Output: 6.0

💡 Note: The tree has subtrees: [5,6,1] with average 4.0, [6] with average 6.0, and [1] with average 1.0. The maximum is 6.0 from the single node subtree containing only 6.

example_2.py — Larger Tree

$ Input: root = [0,null,1]

› Output: 1.0

💡 Note: The tree has subtrees: [0,1] with average 0.5 and [1] with average 1.0. The maximum is 1.0.

example_3.py — Single Node

$ Input: root = [1]

› Output: 1.0

💡 Note: A tree with only one node has only one subtree [1] with average 1.0.

Visualization

Tap to expand

Understanding the Visualization

Start from Leaf Departments

Calculate individual performance scores (6.0 and 1.0)

Move Up Hierarchy

Parent departments receive performance data from children

Calculate Combined Performance

Root department: (5+6+1)/3 = 4.0 average

Find Maximum

Compare all averages: max(6.0, 1.0, 4.0) = 6.0

Key Takeaway

🎯 Key Insight: By using post-order traversal, we calculate each subtree's statistics exactly once, achieving optimal O(n) time complexity while tracking the maximum average across all departments.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is visited exactly once in the DFS traversal

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, which is O(log n) for balanced trees, O(n) for skewed trees

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-10⁴ ≤ Node.val ≤ 10⁴
All nodes in the tree are guaranteed to be unique

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a single post-order DFS traversal where each node returns both the sum and count of its subtree. This eliminates redundant calculations and achieves O(n) time complexity, making it significantly more efficient than the naive O(n²) approach that recalculates subtree statistics for every node.

Common Approaches

Approach	Time	Space	Notes
✓ Single DFS Traversal (Optimal)	O(n)	O(h)	Calculate sum and count for each subtree in a single post-order traversal
Brute Force (Nested Tree Traversals)	O(n²)	O(h)	For each node, separately calculate sum and count of its subtree

Single DFS Traversal (Optimal) — Algorithm Steps

Start post-order DFS from the root
For each node, recursively get sum and count from left and right children
Calculate current subtree's sum = node.val + left_sum + right_sum
Calculate current subtree's count = 1 + left_count + right_count
Update maximum average if current average is better
Return sum and count to parent node

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Leaves

Calculate sum=6, count=1 and sum=1, count=1

Process Root

Combine: sum=5+6+1=12, count=1+1+1=3

Track Maximum

Compare averages: 6.0, 1.0, 4.0 → max is 6.0

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

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

struct Result {
    int sum;
    int count;
};

double maxAvg = 0;

struct Result dfs(struct TreeNode* node) {
    struct Result result = {0, 0};
    if (!node) {
        return result;
    }
    
    struct Result left = dfs(node->left);
    struct Result right = dfs(node->right);
    
    int currSum = node->val + left.sum + right.sum;
    int currCount = 1 + left.count + right.count;
    
    double currAvg = (double)currSum / currCount;
    maxAvg = fmax(maxAvg, currAvg);
    
    result.sum = currSum;
    result.count = currCount;
    return result;
}

double maximumAverageSubtree(struct TreeNode* root) {
    maxAvg = 0;
    dfs(root);
    return maxAvg;
}

int main() {
    struct TreeNode* root = malloc(sizeof(struct TreeNode));
    root->val = 5;
    root->left = malloc(sizeof(struct TreeNode));
    root->left->val = 6;
    root->left->left = root->left->right = NULL;
    root->right = malloc(sizeof(struct TreeNode));
    root->right->val = 1;
    root->right->left = root->right->right = NULL;
    
    printf("%.6f\n", maximumAverageSubtree(root));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is visited exactly once in the DFS traversal

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, which is O(log n) for balanced trees, O(n) for skewed trees

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-10⁴ ≤ Node.val ≤ 10⁴
All nodes in the tree are guaranteed to be unique

42.0K Views

Medium Frequency

~15 min Avg. Time

1.4K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Single DFS Traversal (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler