Top MCQs on Queue Data Structure with Answers

Following is pseudo code of a function that takes a Queue as an argument, and uses a stack S to do processing. 

void fun(Queue *Q) {
    Stack S;  // Say it creates an empty stack S

    // Run while Q is not empty
    while (!isEmpty(Q)) {
        // deQueue an item from Q and push the dequeued item to S
        push(&S, deQueue(Q));
    }

    // Run while Stack S is not empty
    while (!isEmpty(&S)) {
        // Pop an item from S and enqueue the popped item to Q
        enQueue(Q, pop(&S));
    }
}

void fun(Queue *Q)
{
    Stack S;  // Say it creates an empty stack S

    // Run while Q is not empty
    while (!isEmpty(Q))
    {
        // deQueue an item from Q and push the dequeued item to S
        push(&S, deQueue(Q));
    }

    // Run while Stack S is not empty
    while (!isEmpty(&S))
    {
      // Pop an item from S and enqueue the popped item to Q
      enQueue(Q, pop(&S));
    }
}

void fun(Queue Q) {
    Stack S = new Stack();  // Say it creates an empty stack S

    // Run while Q is not empty
    while (!Q.isEmpty()) {
        // deQueue an item from Q and push the dequeued item to S
        S.push(Q.deQueue());
    }

    // Run while Stack S is not empty
    while (!S.isEmpty()) {
        // Pop an item from S and enqueue the popped item to Q
        Q.enQueue(S.pop());
    }
}

def fun(Q):
    S = []  # Say it creates an empty stack S

    # Run while Q is not empty
    while not Q.is_empty():
        # deQueue an item from Q and push the dequeued item to S
        S.append(Q.deQueue())

    # Run while Stack S is not empty
    while S:
        # Pop an item from S and enqueue the popped item to Q
        Q.enQueue(S.pop())

function fun(Q) {
    let S = [];  // Say it creates an empty stack S

    // Run while Q is not empty
    while (!Q.isEmpty()) {
        // deQueue an item from Q and push the dequeued item to S
        S.push(Q.deQueue());
    }

    // Run while Stack S is not empty
    while (S.length > 0) {
        // Pop an item from S and enqueue the popped item to Q
        Q.enQueue(S.pop());
    }
}

What does the above function do in general?

How many stacks are needed to implement a queue. Consider the situation where no other data structure like arrays, linked list is available to you.

Which of the following operations on a queue data structure has a time complexity of O(1)? 

A) Enqueue 
B) Dequeue 
C) Peek 
D) Clear

A priority queue can efficiently implemented using which of the following data structures? Assume that the number of insert and peek (operation to see the current highest priority item) and extraction (remove the highest priority item) operations are almost same.

Which of the following is true about linked list implementation of queue?

A Priority-Queue is implemented as a Max-Heap. Initially, it has 5 elements. The level-order traversal of the heap is given below: 10, 8, 5, 3, 2 Two new elements ”1‘ and ”7‘ are inserted in the heap in that order. The level-order traversal of the heap after the insertion of the elements is:

An implementation of a queue Q, using two stacks S1 and S2, is given below: 

Function Insert(Q, x):
    Push x onto stack S1

Function Delete(Q):
    If stack S2 is empty:
        If stack S1 is also empty:
            Print "Q is empty"
            Return
        Else:
            While stack S1 is not empty:
                Pop element from stack S1 and store it in x
                Push x onto stack S2
    Pop element from stack S2 and store it in x
    Return x  // Or process the popped element (if needed)

Let n insert and m (<=n) delete operations be performed in an arbitrary order on an empty queue Q. Let x and y be the number of push and pop operations performed respectively in the process. Which one of the following is true for all m and n?

Consider the following operation along with Enqueue and Dequeue operations on queues, where k is a global parameter.

MultiDequeue(Q){
   m = k
   while (Q is not empty and m  > 0) {
      Dequeue(Q)
      m = m - 1
   }
}

What is the worst case time complexity of a sequence of n MultiDequeue() operations on an initially empty queue? (A) [Tex]\\Theta(n)  [/Tex](B) [Tex]\\Theta(n + k)  [/Tex](C) [Tex]\\Theta(nk)  [/Tex](D) [Tex]\\Theta(n^2) [/Tex]

Consider the following pseudo-code. Assume that IntQueue is an integer queue. What does the function fun do? 

fun(int n)
{    IntQueue q = new IntQueue();
    q.enqueue(0);    q.enqueue(1);
    for (int i = 0; i < n; i++)
    { 
       int a = q.dequeue();
        int b = q.dequeue();
        q.enqueue(b);
        q.enqueue(a + b);
        print(a);
    }
}

Which of the following is NOT a common operation in a queue data structure?