Maximum Binary Tree II - Practice Coding Problems

Maximum Binary Tree II - Problem

A maximum binary tree is a fascinating data structure where every node has a value greater than any value in its subtree. Think of it as a hierarchy where each parent is always the "boss" of everyone below them!

You're given the root of an existing maximum binary tree and a new integer val. The original tree was built using this process:

Find the largest element in the array - this becomes the root
Everything to the left of the max becomes the left subtree
Everything to the right of the max becomes the right subtree
Recursively apply this process

Your mission: Add val to the end of the original array and return the new maximum binary tree that would be constructed from this extended array.

For example, if the original array was [3,2,1,6,0,5] and val = 4, you need to return the tree that would be built from [3,2,1,6,0,5,4].

Input & Output

example_1.py — Basic Insertion

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

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

💡 Note: Since 5 > 4 (root), the new value 5 becomes the root of the entire tree, with the original tree becoming its left child.

example_2.py — Right Subtree Insertion

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

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

💡 Note: Since 3 < 5 (root), we traverse the right subtree. 3 < 4, so it doesn't replace 4, and becomes a new right child of 4.

example_3.py — New Root Creation

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

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

💡 Note: Since 6 > 5 (root), val becomes the new root with the original tree as its left subtree.

Constraints

The number of nodes in the tree is in the range [1, 100]
1 ≤ Node.val ≤ 100
All the values of the tree are unique
1 ≤ val ≤ 100
It's guaranteed that val does not exist in the original tree

Visualization

Tap to expand

Understanding the Visualization

Check New Authority

When a new person joins, check if they have higher authority than the current CEO

Promote or Place

If yes, they become new CEO with old hierarchy as their department. If no, find their spot in the rightmost chain

Maintain Hierarchy

Since they joined 'at the end', they can only affect the rightmost reporting chain

Final Structure

The hierarchy maintains the property that every manager outranks their entire department

Key Takeaway

🎯 Key Insight: Since the new value is appended to the end of the original array, it can only affect the rightmost path of the maximum binary tree, leading to an elegant O(h) time solution.

Asked in

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

The optimal solution leverages the key insight that since val is appended to the end of the original array, it can only affect the rightmost path of the maximum binary tree. We traverse down the right spine in O(h) time, either making val the new root (if val > root) or finding its correct position in the right subtree, achieving O(1) extra space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Rightmost Path Traversal	O(h)	O(1)	Since val is appended, traverse only the rightmost path to find correct insertion point
Tree Reconstruction (Brute Force)	O(n²)	O(n)	Convert tree to array, append val, rebuild entire tree from scratch

Optimal Rightmost Path Traversal — Algorithm Steps

Start from root and check if val is greater than root value
If yes, val becomes new root with original tree as left child
If no, recursively traverse down the rightmost path
Find the correct position where val should be inserted
Create new node and adjust parent-child relationships

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Root

Compare val with root - if val > root, val becomes new root

Traverse Right

Since val is appended, it can only affect the rightmost path

Find Position

Recursively find where val should be inserted in right subtree

Insert Node

Create new node at the correct position maintaining max tree property

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* insertIntoMaxTree(struct TreeNode* root, int val) {
    // If val is greater than root, it becomes new root
    if (val > root->val) {
        struct TreeNode* newRoot = createNode(val);
        newRoot->left = root;
        return newRoot;
    }
    
    // Otherwise, val must go into right subtree
    if (root->right == NULL) {
        root->right = createNode(val);
    } else {
        root->right = insertIntoMaxTree(root->right, val);
    }
    
    return root;
}

int main() {
    printf("Optimal solution implemented\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(h)

O(h) where h is height of tree, since we only traverse the rightmost path. In worst case O(n), average case O(log n)

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra space for new node creation, plus O(h) recursion stack

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

987 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

Optimal Rightmost Path Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler