Find Largest Value in Each Tree Row

Find Largest Value in Each Tree Row - Problem

Given the root of a binary tree, return an array of the largest value in each row of the tree (0-indexed).

Each row represents all nodes at the same level/depth in the tree. The result should contain the maximum value found at each level, starting from the root level (level 0) down to the deepest level.

Example: For a tree with root value 1, left child 3, and right child 2, where 3 has children 5 and 3, and 2 has child 9, the result would be [1, 3, 9] representing the maximum values at levels 0, 1, and 2 respectively.

Input & Output

Example 1 — Standard Binary Tree

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

› Output: [1,3,9]

💡 Note: Level 0: Only node 1, max = 1. Level 1: Nodes 3 and 2, max = 3. Level 2: Nodes 5, 3, and 9, max = 9.

Example 2 — Single Node Tree

$ Input: root = [1]

› Output: [1]

💡 Note: Tree has only root node at level 0 with value 1.

Example 3 — Left-skewed Tree

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

› Output: [5,4,3,2]

💡 Note: Each level has one node: 5 at level 0, 4 at level 1, 3 at level 2, 2 at level 3.

Constraints

The number of nodes in the tree will be in the range [1, 10⁴].
-2³¹ ≤ Node.val ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

A Amazon 35 F Facebook 28 M Microsoft 22 G Google 18

The key insight is to process the tree level by level, tracking the maximum value at each level. The optimal approach uses BFS (breadth-first search) with a queue to naturally process nodes row by row. Time: O(n), Space: O(w) where w is the maximum width of the tree.

Common Approaches

✓ DFS with Level Tracking

⏱️ Time: O(n) Space: O(h)

Recursively traverse the tree using depth-first search, passing the current level as a parameter. Maintain an array where index represents level and value represents the maximum found at that level so far.

Level-Order Traversal (BFS)

⏱️ Time: O(n) Space: O(w)

Use a queue to perform level-order traversal. Process all nodes at current level before moving to next level, keeping track of the maximum value encountered at each level.

DFS with Level Tracking — Algorithm Steps

Start DFS from root at level 0
For each node, update maximum at current level
Recursively process left and right children at level+1

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin at root level 0, initialize result array

Track Levels

For each node, check if new level or update existing maximum

Recurse

Visit children at level+1, updating maximums as we go

Code -

solution.c — C

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

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

typedef struct {
    TreeNode** nodes;
    int front;
    int rear;
    int capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->nodes = (TreeNode**)malloc(sizeof(TreeNode*) * capacity);
    q->front = 0;
    q->rear = -1;
    q->capacity = capacity;
    return q;
}

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

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

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

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

TreeNode* createNode(int val) {
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

TreeNode* buildTree(char nodes[][10], int nodeCount, int index) {
    if (index >= nodeCount || strcmp(nodes[index], "null") == 0) {
        return NULL;
    }
    
    int val = atoi(nodes[index]);
    TreeNode* root = createNode(val);
    root->left = buildTree(nodes, nodeCount, 2 * index + 1);
    root->right = buildTree(nodes, nodeCount, 2 * index + 2);
    
    return root;
}

int* largestValues(TreeNode* root, int* returnSize) {
    if (!root) {
        *returnSize = 0;
        return NULL;
    }
    
    int* result = (int*)malloc(sizeof(int) * 1000);
    *returnSize = 0;
    
    Queue* q = createQueue(10000);
    enqueue(q, root);
    
    while (!isEmpty(q)) {
        int levelSize = size(q);
        int maxVal = INT_MIN;
        
        for (int i = 0; i < levelSize; i++) {
            TreeNode* node = dequeue(q);
            
            if (node->val > maxVal) {
                maxVal = node->val;
            }
            
            if (node->left) enqueue(q, node->left);
            if (node->right) enqueue(q, node->right);
        }
        
        result[*returnSize] = maxVal;
        (*returnSize)++;
    }
    
    free(q->nodes);
    free(q);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array format [1,3,2,5,3,null,9]
    char nodes[1000][10];
    int nodeCount = 0;
    
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    char token[10];
    int tokenIndex = 0;
    
    while (*ptr && *ptr != ']') {
        if (*ptr == ',' || *ptr == ']') {
            if (tokenIndex > 0) {
                token[tokenIndex] = '\0';
                strcpy(nodes[nodeCount], token);
                nodeCount++;
                tokenIndex = 0;
            }
        } else if (*ptr != ' ') {
            token[tokenIndex++] = *ptr;
        }
        ptr++;
    }
    
    if (tokenIndex > 0) {
        token[tokenIndex] = '\0';
        strcpy(nodes[nodeCount], token);
        nodeCount++;
    }
    
    TreeNode* root = buildTree(nodes, nodeCount, 0);
    int returnSize;
    int* result = largestValues(root, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node exactly once where n is number of nodes

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, plus O(h) for result array

✓ Linear Space

127.0K Views

Medium Frequency

~15 min Avg. Time

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

DFS with Level Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler