CS Free MCQ Bank

[ Option C ]

In a normal or linear queue implemented using an array of size N, the queue becomes full when the value of REAR reaches the last index of the array, that is N−1.

[ Option C ]

These operations are performed on a double-ended queue (deque) or a list that allows insertion and deletion at both front and rear.

• InsertFront(x) places x at the beginning.
• InsertRear(x) places x at the end.
• DeleteFront() removes the first element.
• DeleteRear() removes the last element.

Now apply the operations one by one and show the list after each step:

• InsertFront(10) : 10
• InsertFront(20) : 20 10
• InsertRear(30) : 20 10 30
• DeleteFront() : Removes 20 : 10 30
• InsertRear(40) : 10 30 40
• InsertRear(10) : 10 30 40 10
• DeleteRear() : Removes Last 10 : 10 30 40
• InsertRear(15) : 10 30 40 15
• Display() : Prints 10 30 40 15

So, the final list is 10 30 40 15.

[ Option A ]

In a circular queue implemented using an array, the queue is considered empty when there are no elements stored in it. The most common and standard way to represent an empty circular queue is if front=rear=-1.
When the circular queue is first created, it contains no elements. To show this, both front and rear are initialized to -1. As soon as we insert the first element both front and rear becomes 0. When all elements are deleted again, we reset them to -1 to show the queue is empty.

• When front=rear=0, means one element is present.
• When front=rear+1, this is the condition for circular queue full (no empty space available).

[ Option B ]

First, consider the stack operations (LIFO). The stack is initially empty. After push(54) and push(52), the stack becomes [54, 52]. The pop() operation removes 52. Then push(55) and push(62) make the stack [54, 55, 62]. Finally, s=pop() removes the top element 62, so s=62.
Next, consider the queue operations (FIFO). The queue is initially empty. After enqueue(21) and enqueue(24), the queue becomes [21, 24]. The dequeue() operation removes 21. Then enqueue(28) and enqueue(32) make the queue [24, 28, 32]. Finally, q = dequeue() removes 24, so q=24.
Therefore, s+q = 62+24 = 86

[ Option A ]

A queue follows the FIFO (First In First Out) principle, whereas a stack follows the LIFO (Last In First Out) principle. 
To implement a queue using stacks, we need two stacks. One stack is used for enqueue operations, and the other stack is used for dequeue operations. 
By transferring elements between the two stacks, the order of elements is reversed, which helps achieve FIFO behavior.

[ Option B ]

First, the elements A, B, C, D, E are pushed onto the stack in this order. Since a stack follows LIFO, after all pushes the stack (Top → Bottom) becomes: E, D, C, B, A.

Now, four elements are popped from the stack and inserted into a queue.

Next, two elements are deleted from the queue and pushed back on the stack.

Finally, one item is popped from the stack, which removes the top element D.

[ Option B ]

A data structure in which elements are inserted at the rear and deleted from the front follows the FIFO (First In, First Out) principle. This is exactly how a queue works. In a queue, new data always enters from the rear (back or end), and the oldest data is removed from the front.

[ Option C ]

A Dequeue stands for Double Ended Queue. It is a linear data structure where:

• Insertions and deletions can occur at both ends (front and rear).
• No insertion or deletion is allowed in the middle.

In priority queue, elements are inserted in any order but removed based on priority, not position.
The threaded binary tree is type of binary tree optimized for in-order traversal, not a linear list.
The linked list allows insertions and deletions at any position, including the middle.

[ Option C ]

In a normal Queue, we can insert elements until queue becomes full. But once queue becomes full, we cannot insert the next element even if there is a space in front of queue.
A Circular Queue is a type of queue in which the last position is connected back to the first position, forming a circle. This allows efficient use of memory by reusing empty spaces when elements are deleted. 
Another common name for a circular queue is a Ring Buffer, because conceptually the storage forms a ring where the front and rear wrap around.
If we want to insert new element in circular queue using REAR end, then the value of REAR can be calculated as: REAR=(REAR+1)%CAPACITY
Similarly, when we want to delete existing element from the circular queue using FRONT end, then the value of FRONT can be calculated as: FRONT=(FRONT+1)%CAPACITY

[ Option B ]

To reverse a queue from configuration [a, b, c, d] to [d, c, b, a] using only queue operations, the minimum required is 3 deletions and 3 additions.

[ Option B ]

A Deque (Double-Ended Queue) is a data structure in which elements can be inserted and deleted at both ends, the front as well as the rear but not in the middle.

• In queue, insertion at rear and deletion at front only.
• In stack, insertion, and deletion at the one end called top of the stack.
• In priority queue, deletion is based on priority, not on ends.

[ Option B ]

A queue is a linear data structure in which insertion of elements is performed at one end called rear end and deletion of elements is performed from the other end called front end. This behavior follows the FIFO (First In, First Out) principle.

[ Option A ]

A queue is a linear data structure that manages elements in a specific order, like people waiting in line at a ticket counter, the first to arrive is served first. A queue follows the FIFO (First In, First Out) principle.

• LIFO describes a stack.
• LILO is not a standard term for data-structure behavior. Although it would mean the same as FIFO if interpreted literally, but it is not used.

[ Option C ]

A Circular Queue is also commonly known as a Ring Buffer. It is a data structure that connects the last position back to the first, forming a circle, which allows efficient reuse of buffer space.

Same as queue the circular queue data structure follows the FIFO (First In, First Out) principle and is widely used in scenarios where fixed size buffer management is needed.
The circular queue is empty (underflow) when front == -1 and full (overflow) when (rear + 1) % capacity == front.

[ Option A ]

In a linear queue implemented using an array, overflow occurs when the rear index reaches the last valid index of the array. Since array indexing starts from 0, the last index is MAX_SIZE−1. Once rear becomes MAX_SIZE−1, no more elements can be inserted, even if elements at the front have been dequeued.

[ Option C ]

In a deque implemented using a singly linked list, deletion from the rear end is inefficient. Since the list is singly linked, you do not have a direct pointer to the previous node. To delete the last node, you must traverse the entire list from the start or head to find the second-last node. This traversal takes linear time, i.e., O(N).

[ Option B ]

Common types of queues include the ordinary or linear queue, circular queue, and priority queue.

• The ordinary queue follows standard FIFO queue.
• The circular queue is queue where last position is connected to first.
• In priority queue the elements are removed based on priority.

[ Option C ]

The function myFun(int n) uses a queue-based approach to generate numbers. Initially, two values 0 and 1 are enqueued into the queue. 
Inside the loop, which runs n times, the function dequeues two elements a and b. It then enqueues b back into the queue, followed by a+b. This ensures that the next pair of numbers in the sequence is always available in the queue. During each iteration, the value of a is printed.
This process exactly follows the logic of generating the Fibonacci Sequence, where each number is the sum of the previous two numbers, starting from 0 and 1. Hence, the function prints the first n Fibonacci numbers.

[ Option D ]

A queue data structure has several important applications in the real world. It is commonly used when a resource is shared among multiple consumers, as it manages access by processing requests in a First-In-First-Out (FIFO) manner. This ensures fairness by servicing requests in the order they arrive.
Queues are also used when data is transferred asynchronously between two processes, acting as a buffer to hold data until the receiving process is ready, as seen in the producer-consumer problem with message queues.
Another significant use of queues is in load balancing, where tasks or workloads are distributed evenly across multiple servers or systems by holding tasks in a queue until resources are available to process them.
Overall, queues play a vital role in managing resource sharing, buffering asynchronous data transfer, and balancing workload efficiently in computing systems.

[ Option C ]

A queue is a linear data structure that follows the FIFO (First In, First Out) principle, meaning the first element added is the first one to be removed. There are several applications of queue data structure.

• Asynchronous Data Transfer, data packets, or messages are handled in the order they arrive.
• Resource Sharing, CPU scheduling, printer jobs, or other resources are managed using queues.
• Waiting List, whenever there is a wait in the real-world queue comes into play. All types of customer service centre software’s are designed using queues to store customer’s information.
• Priority, the priority of various objects in the real-world situations is implemented using the queues. The object with the maximum priority is queued on the front and so on.
• Semaphore in operating system, spooling in printer, buffer for devices like keyboard also used queue data structure.

[ Option D ]

A queue follows the FIFO (First In, First Out) principle. This means the element that is inserted first is the one that is removed first. Since the elements A, B, C, and D are placed in the queue in that order, they will also be deleted in the same order: A first, then B, then C, and finally D.

[ Option B ]

A Circular Queue is mainly used to avoid wastage of memory that occurs in a simple linear queue when the front moves forward after deletions but empty spaces at the beginning cannot be reused.

[ Option C ]

A linear data structure that allows insertion and deletion from both the front and the rear is called a Deque (Double-Ended Queue).

• A normal queue allows insertion at rear and deletion from front only.
• A circular queue also follows the same rule but in a circular manner.

A deque is special because it allows:

• Insert at front.
• Insert at rear.
• Delete from front.
• Delete from rear.

[ Option B ]

A queue is a linear data structure that follows the FIFO (First In, First Out) principle. This means the first added element to the queue will be the first one to be removed. There are mainly two operations enqueue (adding an element at the rear end) and dequeue (removing an element from the front end).

[ Option B ]

Before deleting an element from a queue, we must ensure that the queue is not empty. If the queue is empty, deletion is not possible, and this condition is called underflow.

[ Option C ]

A priority queue works by always removing the element with the highest priority first, not necessarily the first inserted one.
The best data structure for implementing a priority queue is the Binary Heap because this organizes data in such a way that both insertion and deletion of the highest-priority element take only O(log n) time, making it far more efficient and suitable.

[ Option A ]

In a circular queue implemented using an array of capacity N, the queue is considered full when the next position of REAR after circular increment becomes equal to FRONT. This condition indicates that there is no empty space left for inserting a new element.

[ Option A ]

Push elements onto stack in reverse order starting from G.

Pop 5 elements from stack and enqueue into queue.

Dequeue 2 elements and push back onto stack.

Finally pop from stack.

[ Option D ]

A queue is a linear data structure that follows the FIFO (First In, First Out) principle. Over time, several variations of queues have been developed to solve different problems.
TYPES OF QUEUES:
Linear Queue: The simplest type of queue, where elements are inserted at the rear and deleted from the front.
Circular Queue: A variation of the linear queue, where the last position is connected back to the first to form a circle, allowing efficient use of space.
Double-ended Queue (Deque): A queue where insertion and deletion can be done from both ends (front and rear). It supports more flexible operations than simple linear or circular queues.