Queues

Question 1

What condition indicates an empty circular queue?

A. rear == size
B. rear == front - 1
C. front == rear
D. front == -1

Answer 1

D. front == -1

Question 2

Which queue type is best suited for continuous insertion and deletion?

A. Stack
B. Array Queue
C. Linear Queue
D. Circular Queue

Answer 2

D. Circular Queue

Question 3

What happens when a dequeue operation is performed on an empty queue?

A. Overflow
B. Underflow
C. Null Return
D. -999

Answer 3

D. -999

Question 4

What principle does a linear queue follow?

A. Random
B. FILO
C. LIFO
D. FIFO

Answer 4

D. FIFO

Question 5

Which operation inserts an element into a queue?

A. Peek
B. Pop
C. Enqueue
D. Dequeue

Answer 5

C. Enqueue

Question 6

Which operation retrieves the front element without removing it?

A. Pop
B. Peek
C. Dequeue
D. Enqueue

Answer 6

B. Peek

Question 7

Which queue type may falsely appear full due to fixed array limits?

A. Stack
B. Linear Queue
C. Linked Queue
D. Circular Queue

Answer 7

B. Linear Queue

Question 8

Which pointer update causes wrap-around in circular queues?

A. rear = size - rear
B. rear = (rear + 1) % size
C. rear = rear + 1
D. rear = rear - 1

Answer 8

B. rear = (rear + 1) % size

Question 9

Which queue uses modulo arithmetic to manage pointer movement?

A. Circular Queue
B. Array Queue
C. Linear Queue
D. Stack

Answer 9

A. Circular Queue

Question 10

How is the front index updated in a circular queue after deletion?

A. front = front - 1
B. front = size - front
C. front = front + 1
D. front = (front + 1) % size

Answer 10

D. front = (front + 1) % size

Question 11

Which queue type prevents memory wastage by wrapping around the array?

A. Circular Queue
B. Linked Queue
C. Linear Queue
D. Stack

Answer 11

A. Circular Queue

Question 12

Which queue type allows reuse of vacant spaces after deletion?

A. Array Queue
B. Linear Queue
C. Stack
D. Circular Queue

Answer 12

D. Circular Queue

Question 13

What condition indicates a full circular queue?

A. (rear + 1) % size == front
B. rear == size - 1
C. rear == front - 1
D. front == rear

Answer 13

A. (rear + 1) % size == front

Question 14

How is the rear index updated in a circular queue after insertion?

A. rear = size - rear
B. rear = rear - 1
C. rear = rear + 1
D. rear = (rear + 1) % size

Answer 14

D. rear = (rear + 1) % size

Question 15

Which queue type is more memory-efficient for fixed-size arrays?

A. Linear Queue
B. Stack
C. Circular Queue
D. Array Queue

Answer 15

C. Circular Queue

Question 16

Which operation removes the front element from a queue?

A. Push
B. Dequeue
C. Peek
D. Enqueue

Answer 16

B. Dequeue

Question 17

What condition indicates a full linear queue (array-based)?

A. front == rear
B. front == -1
C. rear == front
D. rear == size - 1

Answer 17

D. rear == size - 1

Question 18

What is the initial value of front and rear in an empty linear queue?

A. 0
B. -1
C. 1
D. NULL

Answer 18

B. -1

Question 19

In circular queues, which arithmetic operation ensures pointer reset?

A. Division
B. Modulo
C. Addition
D. Subtraction

Answer 19

B. Modulo

Question 20

Which queue type cannot reuse space after front deletions?

A. Stack
B. Linked Queue
C. Linear Queue
D. Circular Queue

Answer 20

C. Linear Queue

Question 21

What is the output of the following code?

queue q = new(queue, 3)
enqueue(q, 4)
enqueue(q, 8)
enqueue(q, 12)
enqueue(q, 16)

A. Queue Overflow
B. 16
C. -999
D. [4, 8, 12, 16]

Answer 21

A. Queue Overflow

Question 22

Which of the following correctly completes the enqueue method below?

public int enqueue(T el) {
if (isFull()) return -999;
if (isEmpty()) front = 0;
rear = (rear + 1) % maxQSize;
que[_____] = _____;
return 1;
}

A. rear + 1, el
B. maxQSize, el
C. front, el
D. rear, el

Answer 22

D. rear, el

Question 23

What is the output of the following code?

queue q = new(queue, 3)
enqueue(q, 5)
enqueue(q, 10)
dequeue(q)
print(q.que[q.front])

Answer 23

10

Question 24

Which of the following correctly completes the dequeue method below?

public int dequeue() {
if (isEmpty(q))
return -999;
else {
int el = q.que[q.front];
if (q.front == q.rear)
clear();
else
q.front = (q.front + 1) % maxQSize;
_____;
}
}

A. return q.que[q.front];
B. return q.rear;
C. return q.front;
D. return el;

Answer 24

D. return el;

Question 25

What is the output of the following code? queue q = new(queue, 3) enqueue(q, 1) enqueue(q, 2) enqueue(q, 3) dequeue(q) dequeue(q) print(q.que[q.front])

Answer 25

3

Question 26

What is the output of the following code? queue q = new(queue, 4) enqueue(q, 8) enqueue(q, 16) print(q.que[q.front])

Answer 26

8

Question 27

Which algorithm correctly implements enqueue in a circular queue? A. if (rear == size - 1) return -999; rear++; queue[rear] = data; B. if (rear == front) return -999; rear = rear + 1; queue[rear] = data; C. if (rear == size) return -999; rear = 0; queue[rear] = data; D. if ((rear + 1) % size == front) return -999; rear = (rear + 1) % size; queue[rear] = data;

Answer 27

D

Question 28

What is the output of the following code? queue q = new(queue, 3) enqueue(q, 7) enqueue(q, 14) dequeue(q) enqueue(q, 21) print(q.que[q.rear])

Answer 28

21

Question 29

What is the output of the following code? queue q = new(queue, 3) dequeue(q)

Answer 29

-999

Question 30

Complete the program segment below: public void enqueue(int data) { if (rear == size) System.out.printf("\nQueue is full"); else queue[_____] = _____; } A. rear + 1, data B. front, data C. rear, data D. size, rear

Answer 30

C. rear, data

Question 31

Which queue type uses modulo arithmetic to maintain continuity in storage? A. Circular Queue B. Linear Queue C. Priority Queue D. Deque

Answer 31

A. Circular Queue

Question 32

Which index increases when an element is removed from a linear queue? A. Front index B. Rear index C. Middle index D. None

Answer 32

A. Front index

Question 33

Which queue type allows insertion even after deletion without shifting elements? A. Linear Queue B. Priority Queue C. Circular Queue D. Deque

Answer 33

C. Circular Queue

Question 34

Which index is updated when inserting an element in a circular queue? A. Front index B. Rear index C. Middle index D. None

Answer 34

B. Rear index

Question 35

Which condition checks for overflow in a circular queue? A. front == rear B. rear == size - 1 C. (rear + 1) % size == front D. front > rear

Answer 35

C. (rear + 1) % size == front

Question 36

Why does a linear queue fail to reuse space after deletion? A. Full array B. Pointer error C. Size mismatch D. No wrap-around logic

Answer 36

D. No wrap-around logic

Question 37

Which end of a linear queue is used for removing elements? A. Rear index B. Middle index C. None D. Front index

Answer 37

D. Front index

Question 38

Which formula updates the front index in a circular queue after deletion? A. front = (front + 1) % size B. rear = (rear + 1) % size C. front = 0 D. front = front - 1

Answer 38

A. front = (front + 1) % size

Question 39

What happens when the rear index reaches the end of the array in a circular queue? A. Rear index resets to 0 B. Rear index stops updating C. Rear index overflows D. Front index resets

Answer 39

A. Rear index resets to 0

Question 40

Which formula updates the rear index in a circular queue after insertion? A. front = (front + 1) % size B. rear = rear + 1 C. rear = 0 D. rear = (rear + 1) % size

Answer 40

D. rear = (rear + 1) % size

Question 41

Which queue type solves the problem of unused space in array-based queues? A. Linear Queue B. Circular Queue C. Priority Queue D. Deque

Answer 41

B. Circular Queue

Question 42

What does the dequeue operation do in a linear queue? A. Deletes from rear B. Inserts from front C. Inserts from rear D. Deletes from front

Answer 42

D. Deletes from front

Question 42

What does the enqueue operation modify in a queue implemented with arrays? A. Front index B. Rear index C. Both D. None

Answer 42

B. Rear index

Question 43

What condition is used to check if a linear queue is empty? A. rear > front B. front == -1 C. front > rear D. rear == size

Answer 43

B. front == -1

Question 44

What happens to the front index after multiple deletions in a linear queue? A. It moves forward B. It resets to 0 C. It stays the same D. It decreases

Answer 44

A. It moves forward

Question 45

Which condition checks for underflow in a circular queue? A. front == -1 B. rear == -1 C. rear == front D. rear > front

Answer 45

A. front == -1

Question 46

What is the main drawback of a linear queue using arrays? A. Complex structure B. Wasted space after deletion C. Hard to implement D. No indexing

Answer 46

B. Wasted space after deletion

Question 47

Which index is updated when deleting an element in a circular queue? A. Rear index B. Middle index C. None D. Front index

Answer 47

D. Front index

Question 48

Determine the output of the following pseudocode: queue q = new(queue, 5) enqueue(q, 10) enqueue(q, 20) print(q.que[q.front]) A. 20 B. 5 C. 10 D. Error

Answer 48

10

Question 49

queue q = new(queue, 4) enqueue(q, 1) enqueue(q, 2) enqueue(q, 3) dequeue(q) dequeue(q) enqueue(q, 4) enqueue(q, 5) dequeue(q) Which sequence represents the dequeued elements? A. [2, 3, 4] B. [1, 2, 3] C. [1, 3, 4] D. [2, 4, 5]

Answer 49

B. [1, 2, 3]

Question 50

Which of the following correctly implements the peek operation for a queue? A. int peek(queue q) { if (isFull(q)) return -999; return q.que[q.rear]; } B. int peek(queue q) { if (isEmpty(q)) return -999; return q.que[q.front]; } C. int peek(queue q) { return q.que[q.rear]; } D. int peek(queue q) { if (q.front == -1) return 0; }

Answer 50

B. int peek(queue q) { if (isEmpty(q)) return -999; return q.que[q.front]; }

Question 51

Which of the following correctly implements the enqueue operation for a linear queue using an array? A. void enqueue(queue q, int el) { if (q.rear == q.size - 1) return; // overflow q.que[++q.rear] = el; } B. void enqueue(queue q, int el) { if (q.rear == q.size) return; q.que[q.rear++] = el; } C. void enqueue(queue q, int el) { q.que[q.front] = el; } D. void enqueue(queue q, int el) { q.que[q.rear] = el; }

Answer 51

A. void enqueue(queue q, int el) { if (q.rear == q.size - 1) return; // overflow q.que[++q.rear] = el; }

Question 52

queue q = new(queue, 5) enqueue(q, 10) enqueue(q, 20) dequeue(q) enqueue(q, 30) enqueue(q, 40) dequeue(q) enqueue(q, 50) What is the current content of the queue from front to rear? A. [20, 30, 40] B. [10, 20, 30] C. [30, 40, 50] D. [40, 50, 60]

Answer 52

C. [30, 40, 50]

Question 53

queue q = new(queue, 3) dequeue(q) What is the output of the pseudocode? A. Queue Overflow B. Segmentation Fault C. Queue Underflow D. -999

Answer 53

D. -999

Question 54

queue q = new(queue, 5) enqueue(q, 10) enqueue(q, 20) print(q.que[q.front]) A. 20 B. 10 C. -999 D. 0

Answer 54

B. 10

Question 55

queue q = new(queue, 3) enqueue(q, 1) enqueue(q, 2) enqueue(q, 3) dequeue(q) enqueue(q, 4) print(q.que[q.rear]) A. 4 B. 3 C. 2 D. 1

Answer 55

A. 4

Question 56

Which of the following correctly handles overflow in enqueue for a circular queue? A. void enqueue(queue q, int el) { if (isFull(q)) return; q.que[q.front] = el; } B. void enqueue(queue q, int el) { if (isFull(q)) return; q.rear++; q.que[q.rear] = el; } C. void enqueue(queue q, int el) { if (isFull(q)) return; q.rear = (q.rear + 1) % q.size; q.que[q.rear] = el; } D. void enqueue(queue q, int el) { q.rear = 0; q.que[q.rear] = el; }

Answer 56

C. void enqueue(queue q, int el) { if (isFull(q)) return; q.rear = (q.rear + 1) % q.size; q.que[q.rear] = el; }

Question 57

queue q = new(queue, 4) enqueue(q, 7) enqueue(q, 8) dequeue(q) enqueue(q, 9) enqueue(q, 10) What is the value at the rear index? A. 9 B. 10 C. 7 D. 8

Answer 57

B. 10

Question 58

queue q = new(queue, 5) enqueue(q, 10) enqueue(q, 20) dequeue(q) print(q.que[q.front]) A. 10 B. 20 C. 30 D. -999

Answer 58

B. 20