Cartesian Tree Builder - Problem

Build a Cartesian Tree from an array of integers in O(n) time using a stack-based approach. A Cartesian Tree is a binary tree derived from a sequence of numbers with these properties:

1. Binary Search Tree (BST) property: In-order traversal gives the original array sequence

2. Min-Heap property: Each parent node has a value smaller than both children

Your task is to construct the tree and verify both properties hold. Return a list containing two boolean values: [isBST, isMinHeap] where the first indicates if the BST property holds and the second indicates if the min-heap property holds.

Note: The tree structure is uniquely determined by the array values and their positions.

Input & Output

Example 1 — Basic Case

$ Input: arr = [3,1,6,4,5]

› Output: [true,true]

💡 Note: Cartesian tree has 1 as root (minimum), 3 as left child, and 6,4,5 form right subtree. In-order traversal gives [3,1,6,4,5] (BST property ✓) and all parents are smaller than children (min-heap property ✓)

Example 2 — All Increasing

$ Input: arr = [1,2,3,4,5]

› Output: [true,true]

💡 Note: Creates a right-skewed tree with 1 as root. In-order traversal: [1,2,3,4,5] (BST ✓). Each parent < children (min-heap ✓)

Example 3 — All Decreasing

$ Input: arr = [5,4,3,2,1]

› Output: [true,true]

💡 Note: Creates a left-skewed tree with 1 as root at the end. In-order: [5,4,3,2,1] (BST ✓). Min-heap property holds (min-heap ✓)

Constraints

1 ≤ arr.length ≤ 1000
1 ≤ arr[i] ≤ 1000
All elements in arr are distinct

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 15 M Microsoft 12

The key insight is using a stack to maintain the rightmost path while building the Cartesian tree. The optimal stack-based approach achieves O(n) time by processing each element exactly once. Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force Recursive

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

Find the minimum element in the array to use as root, then recursively build left subtree from elements to the left and right subtree from elements to the right. Finally verify both BST and min-heap properties.

Stack-Based O(n)

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

Build the tree using a stack to maintain the rightmost path from root. For each element, pop from stack until finding the correct parent, then insert the new node appropriately.

Brute Force Recursive — Algorithm Steps

Step 1: Find minimum element index in current array segment
Step 2: Make minimum element the root of current subtree
Step 3: Recursively build left subtree from left portion
Step 4: Recursively build right subtree from right portion
Step 5: Verify BST property (in-order traversal)
Step 6: Verify min-heap property (parent < children)

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Minimum

Scan array to find minimum element as root

Divide

Split array at minimum into left and right parts

Recurse

Recursively build left and right subtrees

Verify

Check BST and min-heap properties

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.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* buildCartesianTree(int* arr, int start, int end) {
    if (start > end) return NULL;
    
    int minIdx = start;
    for (int i = start + 1; i <= end; i++) {
        if (arr[i] < arr[minIdx]) {
            minIdx = i;
        }
    }
    
    struct TreeNode* root = createNode(arr[minIdx]);
    root->left = buildCartesianTree(arr, start, minIdx - 1);
    root->right = buildCartesianTree(arr, minIdx + 1, end);
    return root;
}

void checkBST(struct TreeNode* root, int* inorder, int* idx) {
    if (!root) return;
    checkBST(root->left, inorder, idx);
    inorder[(*idx)++] = root->val;
    checkBST(root->right, inorder, idx);
}

bool checkMinHeap(struct TreeNode* root) {
    if (!root) return true;
    if (root->left && root->left->val < root->val) return false;
    if (root->right && root->right->val < root->val) return false;
    return checkMinHeap(root->left) && checkMinHeap(root->right);
}

void solution(int* arr, int size, bool* result) {
    if (size == 0) {
        result[0] = true;
        result[1] = true;
        return;
    }
    
    struct TreeNode* root = buildCartesianTree(arr, 0, size - 1);
    
    int* inorder = (int*)malloc(size * sizeof(int));
    int idx = 0;
    checkBST(root, inorder, &idx);
    
    bool isBST = true;
    for (int i = 0; i < size; i++) {
        if (inorder[i] != arr[i]) {
            isBST = false;
            break;
        }
    }
    
    bool isMinHeap = checkMinHeap(root);
    
    result[0] = isBST;
    result[1] = isMinHeap;
    
    free(inorder);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse array
    int arr[100];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        arr[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    bool result[2];
    solution(arr, size, result);
    
    printf("[%s,%s]\n", result[0] ? "true" : "false", result[1] ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Finding minimum in each subarray takes O(n) time, and we do this for each of n elements in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth can be O(n) in worst case, plus O(n) for tree storage

⚡ Linearithmic Space

25.1K Views

Medium Frequency

~35 min Avg. Time

850 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

Cartesian Tree Builder - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Recursive — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler