Codestin Search App

Maximum Binary Tree - Problem

Imagine you're an architect designing a skyline where each building's height represents a value in an array. Your task is to construct a Maximum Binary Tree using a special recursive algorithm that creates the most prominent structure possible.

Given an integer array nums with no duplicates, build a maximum binary tree following these rules:

Find the Maximum: Create a root node with the maximum value in the current array
Left Subtree: Recursively build the left subtree using all elements to the left of the maximum
Right Subtree: Recursively build the right subtree using all elements to the right of the maximum

For example, with [3,2,1,6,0,5], the maximum is 6 at index 3. So 6 becomes the root, [3,2,1] forms the left subtree, and [0,5] forms the right subtree. This process continues recursively until every element finds its place in this hierarchical structure.

Goal: Return the root of the maximum binary tree built from nums.

Input & Output

example_1.py — Basic Case

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

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

💡 Note: Maximum 6 becomes root. [3,2,1] forms left subtree with 3 as root, 2 as right child, 1 as right child of 2. [0,5] forms right subtree with 5 as root, 0 as left child.

example_2.py — Larger Array

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

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

💡 Note: Same as example 1, but 4 becomes right child of 5 since it comes after 5 in the array and 5 is the maximum in [0,5,4].

example_3.py — Single Element

$ Input: [1]

› Output: [1]

💡 Note: Edge case with single element - it becomes the root with no children.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Find the CEO

Scan the array [3,2,1,6,0,5] to find maximum value 6 - this becomes our root

Divide Departments

Split into left team [3,2,1] and right team [0,5] based on position relative to 6

Recursive Organization

Apply same logic: 3 leads left team, 5 leads right team

Complete Hierarchy

Continue until every person has their position in the organization chart

Key Takeaway

🎯 Key Insight: The monotonic decreasing stack approach leverages the fact that in a maximum binary tree, each node's value is greater than all values in its subtrees, allowing us to build the tree in one efficient pass.

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses a monotonic decreasing stack to build the maximum binary tree in O(n) time. As we iterate through the array, each element either becomes a right child of the current stack top, or it pops smaller elements to become their parent, naturally creating the maximum tree structure in a single pass.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Divide and Conquer	O(n²)	O(n)	Find maximum in each subarray recursively and build tree top-down
Monotonic Stack (Optimal)	O(n)	O(n)	Use a decreasing monotonic stack to build tree in single pass O(n)

Recursive Divide and Conquer — Algorithm Steps

Find the maximum element and its index in the current array segment
Create a new TreeNode with the maximum value
Recursively build the left subtree using elements before the maximum
Recursively build the right subtree using elements after the maximum
Return the root node

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Global Maximum

Scan [3,2,1,6,0,5] to find maximum 6 at index 3

Create Root

Make TreeNode(6) as root of the tree

Split Array

Left subarray [3,2,1], right subarray [0,5]

Recursive Calls

Repeat process for each subarray until single elements

Code -

solution.c — C

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

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

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

struct TreeNode* build(int* nums, int left, int right) {
    if (left > right) return NULL;
    
    // Find maximum value and its index
    int maxIdx = left;
    for (int i = left + 1; i <= right; i++) {
        if (nums[i] > nums[maxIdx]) {
            maxIdx = i;
        }
    }
    
    struct TreeNode* root = createNode(nums[maxIdx]);
    root->left = build(nums, left, maxIdx - 1);
    root->right = build(nums, maxIdx + 1, right);
    
    return root;
}

struct TreeNode* constructMaximumBinaryTree(int* nums, int numsSize) {
    return build(nums, 0, numsSize - 1);
}

void printInorder(struct TreeNode* root) {
    if (root != NULL) {
        printInorder(root->left);
        printf("%d ", root->val);
        printInorder(root->right);
    }
}

int main() {
    int nums[] = {3, 2, 1, 6, 0, 5};
    int size = sizeof(nums) / sizeof(nums[0]);
    
    struct TreeNode* result = constructMaximumBinaryTree(nums, size);
    printf("Inorder traversal: ");
    printInorder(result);
    printf("\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case (sorted array), we scan n elements, then n-1, then n-2... = O(n²)

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth can be O(n) in worst case, plus space for the tree nodes

⚡ Linearithmic Space

52.0K Views

Medium Frequency

~15 min Avg. Time

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

Recursive Divide and Conquer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler