Heap Implementation - Problem

Implement both a min-heap and max-heap data structure with the following operations:

Min-Heap Operations:

insert(value) - Insert a value into the min-heap
extractMin() - Remove and return the minimum element
getMin() - Return the minimum element without removing it

Max-Heap Operations:

insert(value) - Insert a value into the max-heap
extractMax() - Remove and return the maximum element
getMax() - Return the maximum element without removing it

Your task is to process a series of operations and return the final state of both heaps as arrays.

The input will be an array of operations, where each operation is represented as [type, heap, value]:

type: 0 = insert, 1 = extract, 2 = get
heap: 0 = min-heap, 1 = max-heap
value: the value to insert (only for insert operations)

Input & Output

Example 1 — Basic Operations

$ Input: operations = [[0,0,5],[0,1,10],[0,0,3],[1,0],[0,1,8]]

› Output: [[5],[10,8]]

💡 Note: Insert 5 into min-heap, insert 10 into max-heap, insert 3 into min-heap, extract min (removes 3), insert 8 into max-heap. Final state: min-heap=[5], max-heap=[10,8]

Example 2 — Multiple Extractions

$ Input: operations = [[0,0,1],[0,0,4],[0,0,2],[1,0],[1,0]]

› Output: [[4],[]]

💡 Note: Insert 1,4,2 into min-heap → [1,4,2]. Extract min twice → removes 1, then 2. Final min-heap=[4], max-heap=[]

Example 3 — Empty Operations

$ Input: operations = []

› Output: [[],[]]

💡 Note: No operations performed, both heaps remain empty

Constraints

0 ≤ operations.length ≤ 1000
operations[i].length is 2 or 3
0 ≤ operations[i][0] ≤ 2 (operation type)
0 ≤ operations[i][1] ≤ 1 (heap type)
-1000 ≤ operations[i][2] ≤ 1000 (value for insert operations)

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is implementing heaps using array-based binary trees where parent-child relationships are maintained through index arithmetic. The optimal approach uses proper heapify operations (bubble-up/bubble-down) to maintain heap properties in O(log n) time per operation. Time: O(log n), Space: O(n).

Common Approaches

✓ Array with Linear Search

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

Store elements in unsorted arrays. For insert, append to end. For extract operations, scan entire array to find min/max, remove it, and shift remaining elements.

Proper Heap Implementation

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

Implement min-heap and max-heap using array representation of binary tree. Maintain heap property through bubble-up and bubble-down operations after insertions and extractions.

Array with Linear Search — Algorithm Steps

Store elements in unsorted arrays
Insert: append to end of array
Extract: linear search for min/max, remove and shift elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Insert

Add element to end of array

Extract

Scan entire array to find min/max

Result

Remove element and shift remaining

Code -

solution.c — C

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

int** solution(int** operations, int operationsSize, int* operationsColSize, int* returnSize, int** returnColumnSizes) {
    int* minHeap = (int*)malloc(1000 * sizeof(int));
    int* maxHeap = (int*)malloc(1000 * sizeof(int));
    int minSize = 0, maxSize = 0;
    
    for (int i = 0; i < operationsSize; i++) {
        int opType = operations[i][0], heapType = operations[i][1];
        
        if (opType == 0) { // insert
            int value = operations[i][2];
            if (heapType == 0) { // min-heap
                minHeap[minSize++] = value;
            } else { // max-heap
                maxHeap[maxSize++] = value;
            }
        } else if (opType == 1) { // extract
            if (heapType == 0 && minSize > 0) { // extract min
                int minVal = INT_MAX, minIdx = 0;
                for (int j = 0; j < minSize; j++) {
                    if (minHeap[j] < minVal) {
                        minVal = minHeap[j];
                        minIdx = j;
                    }
                }
                for (int j = minIdx; j < minSize - 1; j++) {
                    minHeap[j] = minHeap[j + 1];
                }
                minSize--;
            } else if (heapType == 1 && maxSize > 0) { // extract max
                int maxVal = INT_MIN, maxIdx = 0;
                for (int j = 0; j < maxSize; j++) {
                    if (maxHeap[j] > maxVal) {
                        maxVal = maxHeap[j];
                        maxIdx = j;
                    }
                }
                for (int j = maxIdx; j < maxSize - 1; j++) {
                    maxHeap[j] = maxHeap[j + 1];
                }
                maxSize--;
            }
        }
    }
    
    int** result = (int**)malloc(2 * sizeof(int*));
    result[0] = (int*)malloc(minSize * sizeof(int));
    result[1] = (int*)malloc(maxSize * sizeof(int));
    
    for (int i = 0; i < minSize; i++) result[0][i] = minHeap[i];
    for (int i = 0; i < maxSize; i++) result[1][i] = maxHeap[i];
    
    *returnSize = 2;
    *returnColumnSizes = (int*)malloc(2 * sizeof(int));
    (*returnColumnSizes)[0] = minSize;
    (*returnColumnSizes)[1] = maxSize;
    
    free(minHeap);
    free(maxHeap);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each extract/get operation requires scanning the entire array

⚡ Linearithmic

Space Complexity

O(n)

Two arrays to store heap elements

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

892 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

Heap Implementation - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Array with Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler