Queue and Data Structure Quiz

Which of the following is true about a priority queue?

• It follows the FIFO principle.

• Elements are removed based on their position in the queue.

• Elements are removed based on priority, not order.

• It cannot be implemented using arrays.

Which of the following is a feature of a double-ended queue (Deque)?

• Only one end supports insertions and deletions.

• Both ends support insertions and deletions.

• Only rear end supports insertions.

• Only front end supports deletions.

Which of the following is a drawback of array-based queue representation?

• A. Overflow even when space is available.

• B. Additional memory is required for pointers.

• C. Fixed-size implementation.

• D. Both A and C.

In a circular queue, when the first element is enqueued, what happens to front and rear?

• Both are incremented by 1.

• front is set to 0, rear remains -1.

• Both are set to 0.

• rear is incremented, front remains -1.

What is a primary advantage of using a linked list for queue implementation?

• Fixed-size memory.

• Reduced pointer memory.

• Dynamic memory allocation.

• Simplified operations.

What is missing in the following function for initializing a queue?

struct Queue* createQueue(unsigned capacity) {

struct Queue* queue = (struct Queue*)malloc(sizeof(struct Queue));

queue->capacity = capacity;

queue->front = -1;

queue->rear = -1;

queue->array = ____;

return queue;

}

• malloc(capacity * sizeof(int))

• calloc(queue->capacity, sizeof(int))

• malloc(sizeof(int))

• (int*)malloc(queue->capacity * sizeof(int))

What will be the output of the following code if maxSize = 3 and elements 1, 2, 3, 4 are enqueued?

enqueue(queue, 1);

enqueue(queue, 2);

enqueue(queue, 3);

enqueue(queue, 4);

• All elements are enqueued.

• Overflow error occurs.

• Last element overwrites the first one.

• Program crashes.

What code is missing in this enqueue function to prevent overflow?

void enqueue(struct Queue* queue, int item) {

if (___) {

printf("Queue is full\n");

return;

}

if (queue->front == -1)

queue->front = 0;

queue->array[++queue->rear] = item;

}

• queue->rear == queue->capacity

• queue->rear == queue->capacity - 1

• (queue->rear + 1) % queue->capacity == queue->front

• queue->rear >= queue->capacity

What is the output after the following operations?

enqueue(queue, 10);

enqueue(queue, 20);

enqueue(queue, 30);

printf("%d ", dequeue(queue));

enqueue(queue, 40);

printf("%d", dequeue(queue));

• 10 30

• 10 20

• 20 30

• 40 20

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.