Queue Implementation Using Array in DSA C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a queue in data structures?

A queue is a collection where elements are added at the back (rear) and removed from the front, following the First-In-First-Out (FIFO) principle.

beginner

What does 'enqueue' operation do in a queue implemented using an array?

Enqueue adds an element to the rear (end) of the queue if there is space available in the array.

beginner

What does 'dequeue' operation do in a queue implemented using an array?

Dequeue removes the element from the front of the queue and shifts the remaining elements forward to maintain order.

intermediate

Why do we need to shift elements after dequeue in a simple array queue?

Because the front moves forward, to keep the queue elements contiguous at the start of the array, we shift all elements left by one position after dequeue.

intermediate

What is a limitation of a simple queue implemented using an array without circular logic?

The queue can become full even if there is space at the start of the array because the rear only moves forward and does not wrap around, leading to inefficient space use.

In a queue implemented using an array, where is the new element added?

A At the rear (end) of the array

B At the front (start) of the array

C In the middle of the array

D At any random position

New elements are always added at the rear (end) of the queue.

What happens to the elements after a dequeue operation in a simple array queue?

A They are removed randomly

B They are shifted one position to the left

C They are shifted one position to the right

D They remain in the same place

After dequeue, elements are shifted left to fill the empty front position.

What does FIFO stand for in the context of queues?

A Fast-In-Fast-Out

B First-In-Fast-Out

C First-In-First-Out

D Fast-In-First-Out

FIFO means the first element added is the first one to be removed.

What is a common problem with a simple array queue when many dequeue operations happen?

A The queue loses elements randomly

B The queue automatically resizes

C The queue elements get reversed

D The array becomes full even if there is space at the front

Because the rear only moves forward, the array can appear full even if front positions are empty.

Which operation removes an element from the queue?

A Dequeue

B Enqueue

C Push

D Pop

Dequeue removes the front element from the queue.

Explain how enqueue and dequeue operations work in a queue implemented using an array.

Think about where elements enter and leave the queue and what happens inside the array.

Describe the main limitation of a simple array-based queue and why it happens.

Consider what happens when many elements are dequeued but the array still looks full.

Practice

1. What is the main characteristic of a queue implemented using an array?

easy

A. It follows First-In-First-Out (FIFO) order

B. It follows Last-In-First-Out (LIFO) order

C. It allows random access to elements

D. It stores elements in sorted order

Solution

1. Step 1: Understand queue behavior

   A queue is a data structure where the first element added is the first one to be removed, which is FIFO.

2. Step 2: Compare with options

   It follows First-In-First-Out (FIFO) order correctly states FIFO order. It follows Last-In-First-Out (LIFO) order is LIFO (stack), C allows random access (array), D stores sorted (not queue).

3. Final Answer:

   It follows First-In-First-Out (FIFO) order -> Option A

4. Quick Check:

   Queue = FIFO [OK]

Hint: Queue always removes the oldest element first [OK]

Common Mistakes:

• Confusing queue with stack (LIFO)
• Thinking queue allows random access
• Assuming queue sorts elements automatically

2. Which of the following is the correct way to declare a queue array of size 5 in C?

easy

A. queue int[5];

B. int queue[5];

C. int queue();

D. int queue = new int[5];

Solution

1. Step 1: Recall C array declaration syntax

   In C, arrays are declared as type name[size], e.g., int queue[5];

2. Step 2: Check each option

   int queue[5]; matches correct syntax. queue int[5]; is invalid syntax. int queue(); declares a function, not an array. int queue = new int[5]; is Java-style syntax.

3. Final Answer:

   int queue[5]; -> Option B

4. Quick Check:

   C array declaration = int name[size] [OK]

Hint: C arrays use type name[size] syntax [OK]

Common Mistakes:

• Using Java or other language syntax
• Confusing function declaration with array
• Missing semicolon or brackets

3. Consider this C code snippet for a queue implemented using an array of size 3:

int queue[3];
int front = -1, rear = -1;

// Enqueue 10
rear++;
queue[rear] = 10;
if(front == -1) front = 0;

// Enqueue 20
rear++;
queue[rear] = 20;

// Dequeue
int val = queue[front];
front++;

// Enqueue 30
rear++;
queue[rear] = 30;

// Current queue elements from front to rear?

medium

A. 30 -> null

B. 10 -> 20 -> 30 -> null

C. 20 -> 30 -> null

D. 10 -> 30 -> null

Solution

1. Step 1: Trace enqueue and dequeue operations

   Initially front = -1, rear = -1. Enqueue 10: rear=0, queue[0]=10, front=0. Enqueue 20: rear=1, queue[1]=20. Dequeue: val=queue[front]=queue[0]=10, front=1. Enqueue 30: rear=2, queue[2]=30.

2. Step 2: Identify current queue elements

   front=1, rear=2, so elements are queue[1]=20 and queue[2]=30. Hence queue is 20 -> 30 -> null.

3. Final Answer:

   20 -> 30 -> null -> Option C

4. Quick Check:

   After dequeue, front moves forward; queue = 20, 30 [OK]

Hint: After dequeue, front moves forward; queue shows elements from front to rear [OK]

Common Mistakes:

• Not updating front after dequeue
• Including dequeued elements in output
• Confusing front and rear indices

4. Identify the error in this queue enqueue function using array in C:

void enqueue(int queue[], int *rear, int size, int value) {
    if (*rear == size) {
        printf("Queue is full\n");
        return;
    }
    (*rear)++;
    queue[*rear] = value;
}

medium

A. rear should be compared with size - 1, not size

B. rear should be incremented after inserting value

C. Function should return int instead of void

D. queue array should be dynamically allocated

Solution

1. Step 1: Analyze the full condition

   The check if(*rear == size) is wrong. Array indices are 0 to size-1, so full when *rear == size-1 before incrementing. Current check allows overflow.

2. Step 2: Compare options

   rear should be compared with size - 1, not size identifies the correct fix: compare with size-1, not size. Others are incorrect.

3. Final Answer:

   rear should be compared with size - 1, not size -> Option A

4. Quick Check:

   Full: *rear == size-1 [OK]

Hint: Full check: rear == size - 1 [OK]

Common Mistakes:

• Comparing rear == size instead of size-1
• Incorrect overflow condition
• Ignoring zero-based indexing

5. You have a queue implemented using an array of size 4 with front = 1 and rear = 3. After dequeuing two elements and enqueuing one element, what will be the correct front and rear values if you implement a circular queue?

hard

A. front = 2, rear = 0

B. front = 3, rear = 1

C. front = 0, rear = 1

D. front = 3, rear = 0

Solution

1. Step 1: Understand initial state and operations

   Initial: front=1, rear=3, size=4. Dequeue twice: front moves forward twice. Since circular, front = (1 + 2) % 4 = 3.

2. Step 2: Enqueue one element

   rear moves forward by one circularly: rear = (3 + 1) % 4 = 0.

3. Final Answer:

   front = 3, rear = 0 -> Option D

4. Quick Check:

   Circular queue uses modulo for front and rear [OK]

Hint: Use modulo to wrap front and rear in circular queue [OK]

Common Mistakes:

• Not using modulo for circular increment
• Updating front or rear incorrectly
• Confusing front and rear positions