Quiz on Queue Concepts 1

Which of the following correctly describes the operation of a queue?

• Last-In-First-Out (LIFO)

• First-In-First-Out (FIFO)

• Last-In-Last-Out (LILO)

• None of the above

What condition indicates a queue is empty in an array implementation?

• rear == capacity - 1

• front == rear

• front == -1 && rear == -1

• front > rear

In the initialization of a queue, what are the initial values of front and rear?

• 0, 0

• -1, -1

• 0, -1

• None of the above

How is an overflow condition determined in a circular queue?

• rear == front

• (front == rear + 1) || (front == 0 && rear == maxSize - 1)

• front == -1

• rear == maxSize

During the enqueue operation of a simple array-based queue, what happens when the queue is full?

• The rear pointer is reset to -1.

• Elements are shifted left.

• The enqueue operation is blocked.

• The rear pointer cycles to 0.

What is printed by this code after enqueue operations? enqueue(queue, 5); enqueue(queue, 10); printf("Front: %d", queue->array[queue->front]);

• Front: 5

• Front: 10

• Undefined behavior

• No output (program crashes).

What condition should replace ___ in the following dequeue function? int dequeue(struct Queue* queue) { if (___) { printf("Queue is empty\n"); return -1; } int item = queue->array[queue->front]; if (queue->front == queue->rear) { queue->front = queue->rear = -1; } else { queue->front = (queue->front + 1) % queue->capacity; } return item; }

• queue->rear == queue->capacity

• queue->front == queue->rear

• queue->front == -1 && queue->rear == -1

• queue->front == -1

What is wrong with the following dequeue function in a circular queue?

int dequeue(struct Queue* queue) {

if (isEmpty(queue)) return -1;

int item = queue->array[queue->front];

if (queue->front == queue->rear) {

queue->front = queue->rear = -1;

} else {

queue->front++;

}

return item;

}

• It does not handle circular indexing.

• It does not reset rear.

• queue->rear++ should be added.

• No issue.

What is the return value in the isEmpty function? int isEmpty(struct Queue* queue) { return ___; }

• (queue->front == queue->rear)

• (queue->front == -1 || queue->front > queue->rear)

• (queue->rear == -1)

• (queue->front == queue->capacity - 1)

What is the output of the following code? enqueue(queue, 1); enqueue(queue, 2); enqueue(queue, 3); dequeue(queue); enqueue(queue, 4); enqueue(queue, 5); dequeue(queue); enqueue(queue, 6); print(queue); // Print function prints the queue contents. Assume queue->capacity = 4.

• 3 4 5 6

• 4 5 6 1

• 1 2 3 4

• 3 4 5