Average of Levels in Binary Tree - Practice Coding Problems

Average of Levels in Binary Tree - Problem

Calculate the Average Value at Each Level of a Binary Tree

You are given the root of a binary tree. Your task is to compute the average value of all nodes at each level and return these averages as an array.

🎯 Goal: Traverse the binary tree level by level and calculate the mean value of nodes at each depth.

📥 Input: The root node of a binary tree
📤 Output: An array of floating-point numbers representing the average value at each level

Note: Answers within 10^-5 of the actual answer will be accepted due to floating-point precision.

Example: For a tree with level 0: [3], level 1: [9, 20], level 2: [15, 7], the result would be [3.0, 14.5, 11.0]

Input & Output

example_1.py — Perfect Binary Tree

$ Input: root = [3,9,20,null,null,15,7]

› Output: [3.00000,14.50000,11.00000]

💡 Note: Level 0: [3] → average = 3.0, Level 1: [9,20] → average = (9+20)/2 = 14.5, Level 2: [15,7] → average = (15+7)/2 = 11.0

example_2.py — Single Node Tree

$ Input: root = [1]

› Output: [1.00000]

💡 Note: Only one level with a single node having value 1, so the average is 1.0

example_3.py — Skewed Tree

$ Input: root = [2,null,3,null,4,null,5,null,6]

› Output: [2.00000,3.00000,4.00000,5.00000,6.00000]

💡 Note: Each level has exactly one node, so each average equals the node's value: 2.0, 3.0, 4.0, 5.0, 6.0

Visualization

Tap to expand

Understanding the Visualization

Start at Ground Floor

Begin with root node (Floor 0) containing value 3

Process Floor 0

Record value 3, average = 3.0, note children are on Floor 1

Process Floor 1

Record values 9 and 20, average = (9+20)/2 = 14.5, note children are on Floor 2

Process Floor 2

Record values 15 and 7, average = (15+7)/2 = 11.0, no more floors

Final Result

Return array of averages: [3.0, 14.5, 11.0]

Key Takeaway

🎯 Key Insight: BFS naturally processes nodes level by level, making it perfect for calculating averages per level in a single traversal with optimal O(n) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during BFS traversal

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w nodes where w is maximum width of tree (up to n/2 for complete binary tree)

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-2³¹ ≤ Node.val ≤ 2³¹ - 1
Floating point precision: Answers within 10^-5 of the actual answer will be accepted

Asked in

f Facebook 45 a Amazon 38 ⊞ Microsoft 32 G Google 28 Apple 22

The optimal solution uses BFS (Breadth-First Search) with a queue to traverse the tree level by level in a single pass. For each level, we process all nodes currently in the queue, calculate their sum and count, then add their children for the next level. This achieves O(n) time complexity and O(w) space complexity where w is the maximum width of the tree.

Common Approaches

Approach	Time	Space	Notes
✓ BFS Level-Order Traversal (Optimal)	O(n)	O(w)	Use BFS with queue to process nodes level by level in a single pass
Brute Force (Multiple DFS Passes)	O(n * h)	O(h)	Calculate depth, then use DFS for each level to find sum and count

BFS Level-Order Traversal (Optimal) — Algorithm Steps

Initialize queue with root node
While queue is not empty:
- Get current queue size (nodes at current level)
- Initialize sum = 0 for current level
- Process all nodes at current level:
- Dequeue node, add its value to sum
- Enqueue left and right children if they exist
- Calculate average = sum / count and add to result
Return result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with root node in queue

Process Level 0

Process node 3, add children 9 and 20 to queue

Process Level 1

Process nodes 9 and 20, add children 15 and 7 to queue

Process Level 2

Process nodes 15 and 7, calculate final averages

Code -

solution.c — C

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

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

// Queue implementation for BFS
struct QueueNode {
    struct TreeNode* data;
    struct QueueNode* next;
};

struct Queue {
    struct QueueNode* front;
    struct QueueNode* rear;
    int size;
};

struct Queue* createQueue() {
    struct Queue* q = (struct Queue*)malloc(sizeof(struct Queue));
    q->front = q->rear = NULL;
    q->size = 0;
    return q;
}

void enqueue(struct Queue* q, struct TreeNode* data) {
    struct QueueNode* temp = (struct QueueNode*)malloc(sizeof(struct QueueNode));
    temp->data = data;
    temp->next = NULL;
    
    if (q->rear == NULL) {
        q->front = q->rear = temp;
    } else {
        q->rear->next = temp;
        q->rear = temp;
    }
    q->size++;
}

struct TreeNode* dequeue(struct Queue* q) {
    if (q->front == NULL) return NULL;
    
    struct QueueNode* temp = q->front;
    struct TreeNode* data = temp->data;
    q->front = q->front->next;
    
    if (q->front == NULL) q->rear = NULL;
    
    free(temp);
    q->size--;
    return data;
}

int isEmpty(struct Queue* q) {
    return q->front == NULL;
}

double* averageOfLevels(struct TreeNode* root, int* returnSize) {
    if (!root) {
        *returnSize = 0;
        return NULL;
    }
    
    double* result = (double*)malloc(1000 * sizeof(double)); // Assuming max 1000 levels
    int resultIndex = 0;
    
    struct Queue* queue = createQueue();
    enqueue(queue, root);
    
    while (!isEmpty(queue)) {
        int levelSize = queue->size;
        long long levelSum = 0;
        
        // Process all nodes at current level
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = dequeue(queue);
            levelSum += node->val;
            
            // Add children for next level
            if (node->left) enqueue(queue, node->left);
            if (node->right) enqueue(queue, node->right);
        }
        
        // Calculate average for current level
        result[resultIndex++] = (double)levelSum / levelSize;
    }
    
    *returnSize = resultIndex;
    free(queue);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once during BFS traversal

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w nodes where w is maximum width of tree (up to n/2 for complete binary tree)

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-2³¹ ≤ Node.val ≤ 2³¹ - 1
Floating point precision: Answers within 10^-5 of the actual answer will be accepted

125.0K Views

Medium Frequency

~15 min Avg. Time

3.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

BFS Level-Order Traversal (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler