Priority Queue Introduction and Concept in DSA C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a Priority Queue?

A Priority Queue is a special type of queue where each element has a priority. Elements with higher priority are served before elements with lower priority, unlike a normal queue which serves elements in the order they arrive.

beginner

How does a Priority Queue differ from a regular Queue?

In a regular queue, elements are served in the order they arrive (First-In-First-Out). In a Priority Queue, elements are served based on their priority, not just arrival order.

beginner

What are common operations of a Priority Queue?

Common operations include: Insert (add element with priority), Extract-Max or Extract-Min (remove element with highest or lowest priority), and Peek (view element with highest or lowest priority without removing).

intermediate

Which data structure is often used to implement a Priority Queue efficiently?

A Priority Queue is often implemented using a Heap (usually a binary heap) because it allows fast insertion and removal of the highest priority element.

beginner

Why is a Priority Queue useful in real life?

Priority Queues help manage tasks where some are more urgent than others, like hospital emergency rooms where patients with serious conditions are treated before others, or in computer systems for managing jobs with different importance.

What determines the order of elements in a Priority Queue?

A The size of elements

B The order elements were added

C The priority of elements

D The alphabetical order of elements

Priority Queues serve elements based on their priority, not the order they were added.

Which operation removes the element with the highest priority from a Priority Queue?

A Extract-Max or Extract-Min

B Sort

C Peek

D Insert

Extract-Max or Extract-Min removes the element with the highest or lowest priority.

Which data structure is commonly used to implement a Priority Queue efficiently?

A Linked List

B Heap

C Stack

D Array

Heaps allow fast insertion and removal of highest priority elements, making them ideal for Priority Queues.

In a Priority Queue, if two elements have the same priority, what usually decides which one is served first?

A The element that arrived first

B Random choice

C The element with larger size

D The element with smaller size

Usually, if priorities are equal, the element that arrived first is served first (stable priority queue).

Which of these is NOT a typical use case of a Priority Queue?

A Task scheduling

B Emergency room patient management

C Dijkstra's shortest path algorithm

D Printing documents in order received

Printing documents in order received uses a normal queue, not a priority queue.

Explain what a Priority Queue is and how it works.

Think about how tasks with different importance are handled.

Describe common operations on a Priority Queue and their purpose.

Consider how you add and remove elements based on priority.

Practice

1. What is the main characteristic of a priority queue compared to a regular queue?

easy

A. It does not allow insertion of new elements after creation

B. Elements are always dequeued in the order they were enqueued

C. It only stores elements of the same value

D. Elements are dequeued based on their priority, not just arrival order

Solution

1. Step 1: Understand queue behavior

   A regular queue removes elements in the order they arrive (FIFO).

2. Step 2: Understand priority queue behavior

   A priority queue removes elements based on priority, not arrival order.

3. Final Answer:

   Elements are dequeued based on their priority, not just arrival order -> Option D

4. Quick Check:

   Priority queue = priority-based removal [OK]

Hint: Priority queue removes highest priority first, not first-in [OK]

Common Mistakes:

• Thinking priority queue is same as FIFO queue
• Assuming elements must be unique
• Believing insertion order is always preserved

2. Which of the following is the correct way to declare a priority queue in C using the standard library?

easy

A. There is no built-in priority queue in standard C

B. struct priority_queue pq;

C. PriorityQueue pq = new PriorityQueue();

D. priority_queue<int> pq;

Solution

1. Step 1: Recall C standard library features

   The C standard library does not include a built-in priority queue type.

2. Step 2: Analyze options

   The other options show declaration syntax resembling C++ (priority_queue or struct) or Java (PriorityQueue class), none of which are standard in C.

3. Final Answer:

   There is no built-in priority queue in standard C -> Option A

4. Quick Check:

   C standard library lacks priority queue [OK]

Hint: C standard library lacks priority queue type [OK]

Common Mistakes:

• Confusing C with C++ STL syntax
• Assuming priority queue is built-in in C
• Using Java or C++ syntax in C code

3. Consider the following pseudocode for a max-priority queue operations:

insert(5)
insert(3)
insert(10)
extract_max()
insert(1)
extract_max()

What is the sequence of extracted elements?

medium

A. [10, 3]

B. [5, 3]

C. [10, 5]

D. [3, 1]

Solution

1. Step 1: Insert elements into max-priority queue

   Insert 5, 3, 10. The max element is 10.

2. Step 2: Extract max elements in order

   First extract_max() returns 10. Then insert 1. Next extract_max() returns 5 (next highest).

3. Final Answer:

   [10, 5] -> Option C

4. Quick Check:

   Extracted max elements = [10, 5] [OK]

Hint: Extract max returns highest inserted so far [OK]

Common Mistakes:

• Extracting elements in insertion order
• Confusing min and max priority
• Ignoring new insertions before extraction

4. The following C-like pseudocode tries to implement a priority queue insertion but has a bug:

void insert(int pq[], int *size, int value) {
  pq[*size] = value;
  (*size)++;
  int i = *size - 1;
  while (i > 0 && pq[i] < pq[(i - 1) / 2]) {
    int temp = pq[i];
    pq[i] = pq[(i - 1) / 2];
    pq[(i - 1) / 2] = temp;
    i = (i - 1) / 2;
  }
}

What is the bug in this insertion logic?

medium

A. It uses < instead of > for max-heap property

B. It increments size before inserting value

C. It swaps with wrong parent index

D. It does not update the heap after insertion

Solution

1. Step 1: Understand heap property for max-heap

   Max-heap requires parent >= children, so swap if child > parent.

2. Step 2: Analyze condition in while loop

   Condition uses pq[i] < pq[parent], which is correct for min-heap, not max-heap.

3. Final Answer:

   It uses < instead of > for max-heap property -> Option A

4. Quick Check:

   Max-heap needs child > parent to swap [OK]

Hint: Max-heap swaps when child > parent, not < [OK]

Common Mistakes:

• Using min-heap condition for max-heap
• Incorrect parent index calculation
• Not incrementing size correctly

5. You have a priority queue that stores tasks with integer priorities. You want to process tasks in order of highest priority but also keep track of the order tasks with the same priority were added. Which data structure modification best supports this?

hard

A. Use a simple array sorted by priority only

B. Use a max-heap with a timestamp to break ties

C. Use a queue ignoring priorities

D. Use a stack to process tasks in reverse order

Solution

1. Step 1: Understand requirement for priority and insertion order

   We want highest priority first, but for equal priority, process by insertion order.

2. Step 2: Choose data structure supporting priority and tie-break

   A max-heap with timestamps can break ties by earlier insertion time, preserving order among equals.

3. Final Answer:

   Use a max-heap with a timestamp to break ties -> Option B

4. Quick Check:

   Max-heap + timestamp = priority + insertion order [OK]

Hint: Add timestamp to priority for tie-breaking [OK]

Common Mistakes:

• Ignoring insertion order for equal priorities
• Using simple array without tie-break
• Using stack or queue ignoring priority