Treap (Tree + Heap) - Problem

A Treap (Tree + Heap) is a randomized binary search tree that maintains both BST property on keys and max-heap property on priorities. Each node has a key and a random priority.

Properties:

BST property: For any node, all keys in left subtree < node.key < all keys in right subtree
Heap property: For any node, node.priority >= children priorities

Implement a treap with the following operations:

insert(key, priority) - Insert a key with given priority
search(key) - Search for a key, return true if found
delete(key) - Delete a key from the treap
inorder() - Return inorder traversal of keys

Given a list of operations, execute them and return the final inorder traversal.

Input & Output

Example 1 — Basic Operations

$ Input: operations = [["insert",5,10],["insert",3,15],["insert",7,12]]

› Output: [3,5,7]

💡 Note: Insert (5,10), (3,15), (7,12). Node 3 has highest priority 15, becomes root. BST property gives inorder: 3,5,7

Example 2 — With Delete

$ Input: operations = [["insert",10,5],["insert",5,10],["delete",10]]

› Output: [5]

💡 Note: Insert (10,5), then (5,10). Since 5 has higher priority, it becomes root. Delete 10, only 5 remains

Example 3 — Complex Tree

$ Input: operations = [["insert",4,8],["insert",2,12],["insert",6,15],["insert",1,3],["insert",3,7]]

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

💡 Note: Multiple inserts create treap. Node 6 has highest priority 15. Final inorder traversal: 1,2,3,4,6

Constraints

1 ≤ operations.length ≤ 1000
1 ≤ key ≤ 10⁵
1 ≤ priority ≤ 10⁵
All priorities are unique

Visualization

Tap to expand

Asked in

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

The key insight is using tree rotations to maintain both BST property on keys and max-heap property on priorities simultaneously. Best approach uses rotations during insert/delete for O(log n) expected time per operation.

Common Approaches

✓ Brute Force - Linear Search and Rebuild

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

Store all nodes in an array and perform linear search for operations. After each insert/delete, rebuild the entire structure to maintain both BST and heap properties.

Optimized - Tree Rotations

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

Implement a true treap using tree rotations to efficiently maintain both BST property on keys and max-heap property on priorities during insert and delete operations.

Brute Force - Linear Search and Rebuild — Algorithm Steps

Store nodes in unsorted array
For each operation, scan entire array
After modifications, sort and rebuild tree structure

Visualization

Tap to expand

Step-by-Step Walkthrough

Store in Array

Keep all nodes in unsorted array

Linear Operations

Search/insert/delete by scanning entire array

Rebuild Tree

After each modification, rebuild tree structure

Code -

solution.c — C

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

typedef struct TreapNode {
    int key, priority;
    struct TreapNode* left;
    struct TreapNode* right;
} TreapNode;

typedef struct {
    TreapNode** nodes;
    int size;
    int capacity;
} NodeList;

NodeList* createNodeList() {
    NodeList* list = malloc(sizeof(NodeList));
    list->capacity = 100;
    list->nodes = malloc(sizeof(TreapNode*) * list->capacity);
    list->size = 0;
    return list;
}

TreapNode* createNode(int key, int priority) {
    TreapNode* node = malloc(sizeof(TreapNode));
    node->key = key;
    node->priority = priority;
    node->left = node->right = NULL;
    return node;
}

void insertNode(NodeList* list, int key, int priority) {
    // Remove existing key
    for (int i = 0; i < list->size; i++) {
        if (list->nodes[i]->key == key) {
            for (int j = i; j < list->size - 1; j++) {
                list->nodes[j] = list->nodes[j + 1];
            }
            list->size--;
            break;
        }
    }
    
    list->nodes[list->size++] = createNode(key, priority);
    
    // Simple sort by priority (desc)
    for (int i = 0; i < list->size - 1; i++) {
        for (int j = i + 1; j < list->size; j++) {
            if (list->nodes[i]->priority < list->nodes[j]->priority) {
                TreapNode* temp = list->nodes[i];
                list->nodes[i] = list->nodes[j];
                list->nodes[j] = temp;
            }
        }
    }
    
    // Reset pointers
    for (int i = 0; i < list->size; i++) {
        list->nodes[i]->left = list->nodes[i]->right = NULL;
    }
}

void deleteKey(NodeList* list, int key) {
    for (int i = 0; i < list->size; i++) {
        if (list->nodes[i]->key == key) {
            for (int j = i; j < list->size - 1; j++) {
                list->nodes[j] = list->nodes[j + 1];
            }
            list->size--;
            break;
        }
    }
}

void inorderTraverse(TreapNode* node, int* result, int* index) {
    if (node) {
        inorderTraverse(node->left, result, index);
        result[(*index)++] = node->key;
        inorderTraverse(node->right, result, index);
    }
}

int* solution(char operations[][3][20], int opCount, int* returnSize) {
    NodeList* list = createNodeList();
    
    for (int i = 0; i < opCount; i++) {
        if (strcmp(operations[i][0], "insert") == 0) {
            int key = atoi(operations[i][1]);
            int priority = atoi(operations[i][2]);
            insertNode(list, key, priority);
        } else if (strcmp(operations[i][0], "delete") == 0) {
            int key = atoi(operations[i][1]);
            deleteKey(list, key);
        }
    }
    
    int* result = malloc(sizeof(int) * list->size);
    *returnSize = list->size;
    int index = 0;
    
    if (list->size > 0) {
        TreapNode* root = list->nodes[0]; // Highest priority
        inorderTraverse(root, result, &index);
    }
    
    return result;
}

int main() {
    // Simplified for demo
    char ops[3][3][20] = {{"insert", "5", "10"}, {"insert", "3", "15"}, {"insert", "7", "12"}};
    int returnSize;
    int* result = solution(ops, 3, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each operation requires O(n) search and O(n) rebuild, with n operations total

⚡ Linearithmic

Space Complexity

O(n)

Array storage for n nodes plus temporary arrays during rebuild

⚡ Linearithmic Space

8.5K Views

Medium Frequency

~45 min Avg. Time

285 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

Treap (Tree + Heap) - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Linear Search and Rebuild — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler