Priority Queue - Problem

Implement a priority queue data structure using a heap. Your priority queue should support custom priority comparators and handle both min-heap and max-heap operations efficiently.

A priority queue is an abstract data type where each element has an associated priority. Elements with higher priority are served before elements with lower priority. When two elements have the same priority, they are served according to their order in the queue.

You need to implement the following operations:

insert(value, priority) - Add an element with given priority
extractMax() - Remove and return the element with highest priority
peek() - Return the element with highest priority without removing it
size() - Return the number of elements in the queue
isEmpty() - Check if the queue is empty

The implementation should use a binary heap for efficient operations and support custom comparator functions to determine priority ordering.

Input & Output

Example 1 — Basic Priority Queue Operations

$ Input: operations = [["insert", 10, 3], ["insert", 5, 5], ["extractMax"], ["peek"], ["insert", 15, 2], ["extractMax"]]

› Output: [5, 10, 15]

💡 Note: Insert 10 with priority 3, insert 5 with priority 5. ExtractMax returns 5 (highest priority). Peek shows 10. Insert 15 with priority 2. ExtractMax returns 10.

Example 2 — Same Priority Values

$ Input: operations = [["insert", 20, 4], ["insert", 30, 4], ["extractMax"], ["extractMax"]]

› Output: [20, 30]

💡 Note: Both elements have priority 4. The order depends on implementation - typically first inserted is returned first when priorities are equal.

Example 3 — Size and Empty Check

$ Input: operations = [["isEmpty"], ["insert", 100, 1], ["size"], ["extractMax"], ["isEmpty"]]

› Output: [true, 1, 100, true]

💡 Note: Initially empty (true), insert 100, size becomes 1, extract returns 100, queue becomes empty again (true).

Constraints

1 ≤ operations.length ≤ 1000
-10⁹ ≤ value ≤ 10⁹
1 ≤ priority ≤ 10⁹
ExtractMax and Peek called only on non-empty queue

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 Apple 28

The key insight is using a binary heap data structure to maintain the priority ordering efficiently. The max heap approach provides O(log n) time complexity for insert and extract operations while keeping the highest priority element at the root for O(1) peek access. Time: O(log n), Space: O(n)

Common Approaches

✓ Brute Force Array

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

Keep all elements in a simple array. For insert operations, append to the end. For extractMax, scan the entire array to find the maximum priority element, remove it, and shift remaining elements.

Max Heap Implementation

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

Implement priority queue using a binary max-heap stored in an array. The heap property ensures parent nodes always have higher priority than children, allowing O(log n) insertions and extractions.

Brute Force Array — Algorithm Steps

Insert: Add new element to end of array
ExtractMax: Linear search through entire array to find maximum
Remove maximum element and shift remaining elements left

Visualization

Tap to expand

Step-by-Step Walkthrough

Insert Elements

Add elements to end of array

Linear Search

Scan all elements to find maximum priority

Extract & Shift

Remove max element and shift remaining left

Code -

solution.c — C

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

typedef struct {
    int value;
    int priority;
} Element;

typedef struct {
    Element* elements;
    int size;
    int capacity;
} PriorityQueueBF;

PriorityQueueBF* createPQ() {
    PriorityQueueBF* pq = malloc(sizeof(PriorityQueueBF));
    pq->elements = malloc(100 * sizeof(Element));
    pq->size = 0;
    pq->capacity = 100;
    return pq;
}

void insert(PriorityQueueBF* pq, int value, int priority) {
    if (pq->size >= pq->capacity) return;
    pq->elements[pq->size].value = value;
    pq->elements[pq->size].priority = priority;
    pq->size++;
}

int extractMax(PriorityQueueBF* pq) {
    if (pq->size == 0) return -1;
    int maxIdx = 0;
    for (int i = 1; i < pq->size; i++) {
        if (pq->elements[i].priority > pq->elements[maxIdx].priority) {
            maxIdx = i;
        }
    }
    int result = pq->elements[maxIdx].value;
    for (int i = maxIdx; i < pq->size - 1; i++) {
        pq->elements[i] = pq->elements[i + 1];
    }
    pq->size--;
    return result;
}

int peek(PriorityQueueBF* pq) {
    if (pq->size == 0) return -1;
    int maxIdx = 0;
    for (int i = 1; i < pq->size; i++) {
        if (pq->elements[i].priority > pq->elements[maxIdx].priority) {
            maxIdx = i;
        }
    }
    return pq->elements[maxIdx].value;
}

int main() {
    PriorityQueueBF* pq = createPQ();
    insert(pq, 10, 3);
    insert(pq, 5, 1);
    insert(pq, 15, 2);
    
    printf("[%d,%d,%d]\n", extractMax(pq), extractMax(pq), extractMax(pq));
    
    free(pq->elements);
    free(pq);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each extract operation requires scanning all n elements to find maximum

⚡ Linearithmic

Space Complexity

O(n)

Array stores all n elements with no additional overhead

⚡ Linearithmic Space

67.0K Views

High Frequency

~25 min Avg. Time

2.2K 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

Priority Queue - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Array — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler