LeetCode //C - 654. Maximum Binary Tree

654. Maximum Binary Tree

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.
 

Example 1:

Input: nums = [3,2,1,6,0,5]
Output: [6,3,5,null,2,0,null,null,1]
Explanation: The recursive calls are as follow:
- The largest value in [3,2,1,6,0,5] is 6. Left prefix is [3,2,1] and right suffix is [0,5].
     - The largest value in [3,2,1] is 3. Left prefix is [] and right suffix is [2,1].
          - Empty array, so no child.
          - The largest value in [2,1] is 2. Left prefix is [] and right suffix is [1].
               - Empty array, so no child.
               - Only one element, so child is a node with value 1.
     - The largest value in [0,5] is 5. Left prefix is [0] and right suffix is [].
               - Only one element, so child is a node with value 0.
               - Empty array, so no child.

Example 2:

Input: nums = [3,2,1]
Output: [3,null,2,null,1]

Constraints:

• 1 <= nums.length <= 1000
• 0 <= nums[i] <= 1000
• All integers in nums are unique.

From: LeetCode
Link: 654. Maximum Binary Tree

---

Solution:

Ideas:

1. constructMaximumBinaryTree() starts the recursive construction.

2. buildTree() is a recursive helper that:

• Finds the max value in the current subarray (left to right).
• Creates a root node with that value.
• Recursively builds left and right subtrees using the subarrays before and after the max element.

Code:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
// Helper function to find index of max element in a subarray
int findMaxIndex(int* nums, int left, int right) {
    
    
    int maxIdx = left;
    for (int i = left + 1; i <= right; i++) {
    
    
        if (nums[i] > nums[maxIdx]) {
    
    
            maxIdx = i;
        }
    }
    return maxIdx;
}

// Recursive function to construct maximum binary tree
struct TreeNode* buildTree(int* nums, int left, int right) {
    
    
    if (left > right) return NULL;

    int maxIdx = findMaxIndex(nums, left, right);
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = nums[maxIdx];
    root->left = buildTree(nums, left, maxIdx - 1);
    root->right = buildTree(nums, maxIdx + 1, right);
    return root;
}

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