Queue DSA Coding Ninjas Completed

Author: RushabhShahPrograms

06_Queue/01_Queue_MCQ.md

@@ -0,0 +1,19 @@
+### Queue
+1. A queue is a?
+
+Ans: **FIFO(First in First Out)**
+
+### Correct Order
+2. If the elements "p","q","r" and "s" are placed in a queue and are deleted one at a time, in what order will they be removed?
+
+Ans: **pqrs**
+
+### Insert Element
+3. In optimized linked list implementation of a queue, where does a new element be inserted?
+a
+Ans: **At the tail of the linked list**
+
+### Worst Case
+4. In the linked list implementation of queue, if only front pointer is maintained, which of the following operation take worst case time (i.e. O(n))?
+
+Ans: **Insertion from rear**

06_Queue/02_Queue_Using_LL.py

@@ -0,0 +1,140 @@
+'''
+Queue Using LL
+
+Implement a Queue Data Structure specifically to store integer data using a Singly Linked List.
+The data members should be private.
+You need to implement the following public functions :
+1. Constructor:
+It initialises the data members as required.
+2. enqueue(data) :
+This function should take one argument of type integer. It enqueues the element into the queue and returns nothing.
+3. dequeue() :
+It dequeues/removes the element from the front of the queue and in turn, returns the element being dequeued or removed. In case the queue is empty, it returns -1.
+4. front() :
+It returns the element being kept at the front of the queue. In case the queue is empty, it returns -1.
+5. getSize() :
+It returns the size of the queue at any given instance of time.
+6. isEmpty() :
+It returns a boolean value indicating whether the queue is empty or not.
+Operations Performed on the Stack:
+Query-1(Denoted by an integer 1): Enqueues an integer data to the queue.
+
+Query-2(Denoted by an integer 2): Dequeues the data kept at the front of the queue and returns it to the caller.
+
+Query-3(Denoted by an integer 3): Fetches and returns the data being kept at the front of the queue but doesn't remove it, unlike the dequeue function.
+
+Query-4(Denoted by an integer 4): Returns the current size of the queue.
+
+Query-5(Denoted by an integer 5): Returns a boolean value denoting whether the queue is empty or not.
+Input Format:
+The first line contains an integer 'q' which denotes the number of queries to be run against each operation on the queue. 
+Then the test cases follow.
+
+Every 'q' lines represent an operation that needs to be performed.
+
+For the enqueue operation, the input line will contain two integers separated by a single space, representing the type of the operation in integer and the integer data being enqueued into the queue.
+
+For the rest of the operations on the queue, the input line will contain only one integer value, representing the query being performed on the queue.
+Output Format:
+For Query-1, you do not need to return anything.
+For Query-2, prints the data being dequeued from the queue.
+For Query-3, prints the data kept on the front of the queue.
+For Query-4, prints the current size of the queue.
+For Query-5, prints 'true' or 'false'(without quotes).
+
+Output for every query will be printed in a separate line.
+ Note:
+You are not required to print anything explicitly. It has already been taken care of. Just implement the functions.
+Constraints:
+1 <= q <= 10^5
+1 <= x <= 5
+-2^31 <= data <= 2^31 - 1 and data != -1
+
+Where 'q' is the total number of queries being performed on the queue, 'x' is the range for every query and data represents the integer pushed into the queue. 
+
+Time Limit: 1 second
+Sample Input 1:
+7
+1 17
+1 23
+1 11
+2
+2
+2
+2
+Sample Output 1:
+17
+23
+11
+-1
+Sample Input 2:
+3
+2
+1 10
+4
+Sample Output 2:
+-1 
+1
+'''
+
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+
+class Queue:
+    def __init__(self):
+        self.__head = None
+        self.__tail = None
+        self.__size = 0
+
+    def enqueue(self, data):
+        new_node = Node(data)
+        if self.__tail is None:
+            self.__head = new_node
+            self.__tail = new_node
+        else:
+            self.__tail.next = new_node
+            self.__tail = new_node
+        self.__size += 1
+
+    def dequeue(self):
+        if self.isEmpty():
+            return -1
+        data = self.__head.data
+        self.__head = self.__head.next
+        self.__size -= 1
+        if self.__head is None:
+            self.__tail = None
+        return data
+
+    def front(self):
+        if self.isEmpty():
+            return -1
+        return self.__head.data
+
+    def getSize(self):
+        return self.__size
+
+    def isEmpty(self):
+        return self.__size == 0
+
+
+# Driver code
+if __name__ == "__main__":
+    queue = Queue()
+
+    q = int(input())
+    for _ in range(q):
+        query = list(map(int, input().split()))
+
+        if query[0] == 1:
+            queue.enqueue(query[1])
+        elif query[0] == 2:
+            print(queue.dequeue())
+        elif query[0] == 3:
+            print(queue.front())
+        elif query[0] == 4:
+            print(queue.getSize())
+        elif query[0] == 5:
+            print(queue.isEmpty())

06_Queue/03_Stack_Using_2_Queues.py

@@ -0,0 +1,152 @@
+'''
+Stack Using 2 Queues
+
+Implement a Stack Data Structure specifically to store integer data using two Queues. You have to implement it in such a way that the push operation is done in O(1) time and the pop and top operations are done in O(N) time.
+There should be two data members, both being Queues to store the data internally. You may use the inbuilt Queue.
+Implement the following public functions :
+1. Constructor:
+It initialises the data members as required.
+2. push(data) :
+This function should take one argument of type integer. It pushes the element into the stack and returns nothing.
+3. pop() :
+It pops the element from the top of the stack and in turn, returns the element being popped or deleted. In case the stack is empty, it returns -1.
+4. top :
+It returns the element being kept at the top of the stack. In case the stack is empty, it returns -1.
+5. size() :
+It returns the size of the stack at any given instance of time.
+6. isEmpty() :
+It returns a boolean value indicating whether the stack is empty or not.
+Operations Performed on the Stack:
+Query-1(Denoted by an integer 1): Pushes an integer data to the stack.
+
+Query-2(Denoted by an integer 2): Pops the data kept at the top of the stack and returns it to the caller.
+
+Query-3(Denoted by an integer 3): Fetches and returns the data being kept at the top of the stack but doesn't remove it, unlike the pop function.
+
+Query-4(Denoted by an integer 4): Returns the current size of the stack.
+
+Query-5(Denoted by an integer 5): Returns a boolean value denoting whether the stack is empty or not.
+Input Format:
+The first line contains an integer 'q' which denotes the number of queries to be run against each operation in the stack. 
+Then the test cases follow.
+
+Every 'q' lines represent an operation that needs to be performed.
+
+For the push operation, the input line will contain two integers separated by a single space, representing the type of the operation in integer and the integer data being pushed into the stack.
+
+For the rest of the operations on the stack, the input line will contain only one integer value, representing the query being performed on the stack.
+Output Format:
+For Query-1, you do not need to return anything.
+For Query-2, prints the data being popped from the stack.
+For Query-3, prints the data kept on the top of the stack.
+For Query-4, prints the current size of the stack.
+For Query-5, prints 'true' or 'false'(without quotes).
+
+Output for every query will be printed in a separate line.
+ Note:
+You are not required to print anything explicitly. It has already been taken care of. Just implement the function.
+Constraints:
+1 <= q <= 100
+1 <= x <= 5
+-2^31 <= data <= 2^31 - 1 and data != -1
+
+Where 'q' is the total number of queries being performed on the stack, 'x' is the range for every query and data represents the integer pushed into the stack. 
+
+Time Limit: 1 second
+Sample Input 1:
+6
+1 13
+1 47
+4
+5
+2
+3
+Sample Output 1:
+2
+false
+47
+13
+Sample Input 2:
+4
+5
+2
+1 10
+5
+ Sample Output 2:
+true
+-1
+false
+'''
+
+from queue import Queue
+
+class StackUsingQueues:
+    def __init__(self):
+        self.q1 = Queue()
+        self.q2 = Queue()
+        self.current_size = 0
+
+    def push(self, data):
+        self.q1.put(data)
+        self.current_size += 1
+
+    def pop(self):
+        if self.isEmpty():
+            return -1
+
+        # Move all elements from q1 to q2 except the last one
+        while self.q1.qsize() > 1:
+            self.q2.put(self.q1.get())
+
+        # Pop the last element from q1
+        popped_element = self.q1.get()
+        self.current_size -= 1
+
+        # Swap q1 and q2
+        self.q1, self.q2 = self.q2, self.q1
+
+        return popped_element
+
+    def top(self):
+        if self.isEmpty():
+            return -1
+
+        # Move all elements from q1 to q2 except the last one
+        while self.q1.qsize() > 1:
+            self.q2.put(self.q1.get())
+
+        # Get the last element from q1
+        top_element = self.q1.get()
+
+        # Swap q1 and q2
+        self.q1, self.q2 = self.q2, self.q1
+
+        # Put the last element back to q1
+        self.q1.put(top_element)
+
+        return top_element
+
+    def size(self):
+        return self.current_size
+
+    def isEmpty(self):
+        return self.current_size == 0
+
+# Driver code
+if __name__ == "__main__":
+    stack = StackUsingQueues()
+
+    q = int(input())
+    for _ in range(q):
+        query = list(map(int, input().split()))
+
+        if query[0] == 1:
+            stack.push(query[1])
+        elif query[0] == 2:
+            print(stack.pop())
+        elif query[0] == 3:
+            print(stack.top())
+        elif query[0] == 4:
+            print(stack.size())
+        elif query[0] == 5:
+            print(stack.isEmpty())

06_Queue/04_Reverse_Queue.py

@@ -0,0 +1,71 @@
+'''
+Reverse Queue
+
+You have been given a queue that can store integers as the data. You are required to write a function that reverses the populated queue itself without using any other data structures.
+Example:
+ 
+ 
+Input Format:
+The first list of input contains an integer 't' denoting the number of test cases/queries to be run.
+Then the test cases follow.
+
+The first line input for each test case/query contains an integer N, denoting the total number of elements in the queue.
+
+The second line of input contains N integers separated by a single space, representing the order in which the elements are enqueued into the queue.
+Output Format:
+For each test case/query, the only line of output prints the order in which the queue elements are dequeued, all of them separated by a single space.
+
+Output for every test case/query will be printed on a new line. 
+Note:
+You are not required to print the expected output explicitly, it has already been taken care of. Just make the changes in the input queue itself.
+Constraints:
+1 <= t <= 100
+1 <= N <= 10^4
+-2^31 <= data <= 2^31 - 1
+
+Time Limit: 1sec 
+Sample Input 1:
+1
+6
+1 2 3 4 5 10
+Note:
+Here, 1 is at the front and 10 is at the rear of the queue.
+Sample Output 1:
+10 5 4 3 2 1
+Sample Input 2:
+2
+5
+2 8 15 1 10
+3
+10 20 30
+Sample Output 2:
+10 1 15 8 2 
+30 20 10
+'''
+
+from queue import Queue
+
+def reverse_queue(queue):
+    stack = []
+
+    while not queue.empty():
+        stack.append(queue.get())
+
+    while stack:
+        queue.put(stack.pop())
+
+if __name__ == "__main__":
+    t = int(input())
+    for _ in range(t):
+        n = int(input())
+        elements = list(map(int,input().split()))
+
+        input_queue = Queue()
+        for element in elements:
+            input_queue.put(element)
+
+        reverse_queue(input_queue)
+
+        while not input_queue.empty():
+            print(input_queue.get(),end=" ")
+        print()