Maximum Binary Tree

Maximum Binary Tree - Problem

You are given an integer array nums with no duplicates. A maximum binary tree can be built recursively from nums using the following algorithm:

1. Create a root node whose value is the maximum value in nums.

2. Recursively build the left subtree on the subarray prefix to the left of the maximum value.

3. Recursively build the right subtree on the subarray suffix to the right of the maximum value.

Return the maximum binary tree built from nums.

Input & Output

Example 1 — Basic Case

$ Input: nums = [3,2,1,6,0,5]

› Output: [6,3,5,null,2,0,null,null,1]

💡 Note: Maximum element 6 becomes root. Left subtree built from [3,2,1] with root 3, right subtree from [0,5] with root 5.

Example 2 — Single Element

$ Input: nums = [3]

› Output: [3]

💡 Note: Single element forms a tree with just the root node.

Example 3 — Sorted Array

$ Input: nums = [1,2,3,4]

› Output: [4,null,3,null,2,null,1]

💡 Note: Maximum is always the rightmost element, creating a right-skewed tree.

Constraints

1 ≤ nums.length ≤ 1000
All integers in nums are unique
0 ≤ nums[i] ≤ 5000

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 f Facebook 8 M Microsoft 6

The key insight is that each element becomes the root of its subtree by being the maximum in its range. The optimal approach uses a monotonic stack to build the tree in a single pass. Time: O(n), Space: O(n).

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Monotonic Stack

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

Traverse array once, maintaining a stack of nodes in decreasing order. When we find a larger element, it becomes parent of smaller elements we pop from stack.

Recursive Divide and Conquer

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

For each subarray, find the maximum element to use as root, then recursively build left subtree from elements before max and right subtree from elements after max.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int expiry;
    int count;
} Batch;

typedef struct {
    Batch* data;
    int size;
    int capacity;
} MinHeap;

MinHeap* createHeap(int capacity) {
    MinHeap* heap = (MinHeap*)malloc(sizeof(MinHeap));
    heap->data = (Batch*)malloc(capacity * sizeof(Batch));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void swap(Batch* a, Batch* b) {
    Batch temp = *a;
    *a = *b;
    *b = temp;
}

void heapifyUp(MinHeap* heap, int idx) {
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (heap->data[parent].expiry <= heap->data[idx].expiry) break;
        swap(&heap->data[parent], &heap->data[idx]);
        idx = parent;
    }
}

void heapifyDown(MinHeap* heap, int idx) {
    while (1) {
        int minIdx = idx;
        int left = 2 * idx + 1;
        int right = 2 * idx + 2;
        
        if (left < heap->size && heap->data[left].expiry < heap->data[minIdx].expiry) {
            minIdx = left;
        }
        if (right < heap->size && heap->data[right].expiry < heap->data[minIdx].expiry) {
            minIdx = right;
        }
        
        if (minIdx == idx) break;
        swap(&heap->data[idx], &heap->data[minIdx]);
        idx = minIdx;
    }
}

void push(MinHeap* heap, int expiry, int count) {
    if (heap->size >= heap->capacity) return;
    heap->data[heap->size].expiry = expiry;
    heap->data[heap->size].count = count;
    heapifyUp(heap, heap->size);
    heap->size++;
}

Batch pop(MinHeap* heap) {
    Batch result = heap->data[0];
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    if (heap->size > 0) {
        heapifyDown(heap, 0);
    }
    return result;
}

int solution(int* apples, int* days, int n) {
    MinHeap* heap = createHeap(n * 2);
    int totalEaten = 0;
    int day = 0;
    
    while (day < n || heap->size > 0) {
        // Add today's apples to heap if within n days
        if (day < n && apples[day] > 0) {
            push(heap, day + days[day], apples[day]);
        }
        
        // Remove expired apples
        while (heap->size > 0 && heap->data[0].expiry <= day) {
            pop(heap);
        }
        
        // Eat one apple from batch expiring soonest
        if (heap->size > 0) {
            Batch batch = pop(heap);
            totalEaten++;
            if (batch.count > 1) {
                push(heap, batch.expiry, batch.count - 1);
            }
        }
        
        day++;
    }
    
    free(heap->data);
    free(heap);
    return totalEaten;
}

int main() {
    char line[1000];
    int apples[100], days[100];
    int n = 0;
    
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        apples[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    int m = 0;
    fgets(line, sizeof(line), stdin);
    token = strtok(line, "[],\n ");
    while (token != NULL) {
        days[m++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", solution(apples, days, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

180.0K Views

Medium Frequency

~15 min Avg. Time

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