Find Largest Value in Each Tree Row - Practice Coding Problems

Find Largest Value in Each Tree Row - Problem

Find the Champion of Each Level

You're given the root of a binary tree and need to find the largest value in each row of the tree. Think of it as finding the "champion" node at each level of the tree hierarchy.

For example, if you have a tree with multiple levels, you need to:
• Examine all nodes at level 0 (root level) and find the maximum
• Examine all nodes at level 1 and find the maximum
• Continue for all levels until you reach the leaves

Return an array where result[i] contains the largest value found at level i of the tree.

Note: The tree levels are 0-indexed, starting from the root.

Input & Output

example_1.py — Basic Binary Tree

$ Input: root = [1,3,2,5,3,null,9]

› Output: [1,3,9]

💡 Note: Level 0: only node 1, so max = 1. Level 1: nodes 3 and 2, so max = 3. Level 2: nodes 5, 3, and 9, so max = 9.

example_2.py — Single Node Tree

$ Input: root = [1]

› Output: [1]

💡 Note: Tree has only one level (level 0) with a single node containing value 1.

example_3.py — Empty Tree

$ Input: root = []

› Output: []

💡 Note: Empty tree has no levels, so return empty array.

Constraints

The number of nodes in tree is in range [0, 10⁴]
-2³¹ ≤ Node.val ≤ 2³¹ - 1
Tree can be empty (null root)

Visualization

Tap to expand

Understanding the Visualization

Level 0 Tournament

Only one participant (root), automatic champion with value 1

Level 1 Tournament

Two participants (3 vs 2), champion is 3

Level 2 Tournament

Three participants (5 vs 3 vs 9), champion is 9

Collect Champions

Final result: [1, 3, 9] representing each level's champion

Key Takeaway

🎯 Key Insight: BFS naturally processes nodes level by level, making it perfect for finding the maximum value at each tree level in a single efficient pass.

Asked in

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

The optimal approach uses BFS (Breadth-First Search) to process nodes level by level. We maintain a queue and process all nodes at the current level before moving to the next, tracking the maximum value at each level. This achieves O(n) time complexity with a single pass through the tree.

Common Approaches

Approach	Time	Space	Notes
✓ BFS Level-by-Level (Optimal)	O(n)	O(w)	Use BFS queue to process one complete level at a time, tracking maximum for each level
DFS with Level Tracking	O(n)	O(h)	Use DFS recursion to traverse tree while tracking current level and updating maximums

BFS Level-by-Level (Optimal) — Algorithm Steps

Start with root in queue, if root exists
While queue is not empty:
Get current level size (nodes in queue)
Process all nodes at current level, tracking maximum
Add children of current level nodes to queue
Add level maximum to result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with root node in queue

Process Level 0

Process root, track max=1, add children to queue

Process Level 1

Process nodes 3,2, track max=3, add their children

Process Level 2

Process nodes 5,3,9, track max=9, queue becomes empty

Code -

solution.c — C

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

#define QUEUE_SIZE 10000

struct Queue {
    struct TreeNode* nodes[QUEUE_SIZE];
    int front, rear;
};

void initQueue(struct Queue* q) {
    q->front = q->rear = 0;
}

void enqueue(struct Queue* q, struct TreeNode* node) {
    q->nodes[q->rear++] = node;
}

struct TreeNode* dequeue(struct Queue* q) {
    return q->nodes[q->front++];
}

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

int size(struct Queue* q) {
    return q->rear - q->front;
}

int* largestValues(struct TreeNode* root, int* returnSize) {
    if (!root) {
        *returnSize = 0;
        return NULL;
    }
    
    int* result = (int*)malloc(1000 * sizeof(int));
    int resultIdx = 0;
    struct Queue queue;
    initQueue(&queue);
    enqueue(&queue, root);
    
    while (!isEmpty(&queue)) {
        int levelSize = size(&queue);
        int levelMax = INT_MIN;
        
        // Process all nodes at current level
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = dequeue(&queue);
            if (node->val > levelMax) {
                levelMax = node->val;
            }
            
            // Add children for next level
            if (node->left) enqueue(&queue, node->left);
            if (node->right) enqueue(&queue, node->right);
        }
        
        result[resultIdx++] = levelMax;
    }
    
    *returnSize = resultIdx;
    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

✓ Linear Space

89.6K Views

Medium Frequency

~15 min Avg. Time

2.3K 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

Constraints

Visualization

Related Problems

Common Approaches

BFS Level-by-Level (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler