Tutorialspoint.dev

Reversing a Queue

Give an algorithm for reversing a queue Q. Only following standard operations are allowed on queue.

  1. enqueue(x) : Add an item x to rear of queue.
  2. dequeue() : Remove an item from front of queue.
  3. empty() : Checks if a queue is empty or not.

Examples:

Input : Q = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
Output :Q = [100, 90, 80, 70, 60, 50, 40, 30, 20, 10]

Input :[1, 2, 3, 4, 5]
Output :[5, 4, 3, 2, 1]



C++

// CPP program to reverse a Queue
#include <bits/stdc++.h>
using namespace std;
  
// Utility function to print the queue
void Print(queue<int>& Queue)
{
    while (!Queue.empty()) {
        cout << Queue.front() << " ";
        Queue.pop();
    }
}
  
// Function to reverse the queue
void reverseQueue(queue<int>& Queue)
{
    stack<int> Stack;
    while (!Queue.empty()) {
        Stack.push(Queue.front());
        Queue.pop();
    }
    while (!Stack.empty()) {
        Queue.push(Stack.top());
        Stack.pop();
    }
}
  
// Driver code
int main()
{
    queue<int> Queue;
    Queue.push(10);
    Queue.push(20);
    Queue.push(30);
    Queue.push(40);
    Queue.push(50);
    Queue.push(60);
    Queue.push(70);
    Queue.push(80);
    Queue.push(90);
    Queue.push(100);
  
    reverseQueue(Queue);
    Print(Queue);
}

Java

// Java program to reverse a Queue
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
  
// Java program to reverse a queue
public class Queue_reverse {
      
    static Queue<Integer> queue;
  
    // Utility function to print the queue
    static void Print()
    {
        while (!queue.isEmpty()) {
            System.out.print( queue.peek() + ", ");
            queue.remove();
        }
    }
  
    // Function to reverse the queue
    static void reversequeue()
    {
        Stack<Integer> stack = new Stack<>();
        while (!queue.isEmpty()) {
            stack.add(queue.peek());
            queue.remove();
        }
        while (!stack.isEmpty()) {
            queue.add(stack.peek());
            stack.pop();
        }
    }
  
    // Driver code
    public static void main(String args[])
    {
        queue = new LinkedList<Integer>();
        queue.add(10);
        queue.add(20);
        queue.add(30);
        queue.add(40);
        queue.add(50);
        queue.add(60);
        queue.add(70);
        queue.add(80);
        queue.add(90);
        queue.add(100);
  
        reversequeue();
        Print();
    }
}
//This code is contributed by Sumit Ghosh

Python3

# Python3 program to reverse a queue
from queue import Queue

# Utility function to print the queue
def Print(queue):
while (not queue.empty()):
print(queue.queue[0], end = “, “)
queue.get()

# Function to reverse the queue
def reversequeue(queue):
Stack = []
while (not queue.empty()):
Stack.append(queue.queue[0])
queue.get()
while (len(Stack) != 0):
queue.put(Stack[-1])
Stack.pop()

# Driver code
if __name__ == ‘__main__’:
queue = Queue()
queue.put(10)
queue.put(20)
queue.put(30)
queue.put(40)
queue.put(50)
queue.put(60)
queue.put(70)
queue.put(80)
queue.put(90)
queue.put(100)

reversequeue(queue)
Print(queue)

# This code is contributed by PranchalK

C#

// c# program to reverse a Queue 
using System;
using System.Collections.Generic;
  
public class GFG
{
  
public static LinkedList<int> queue;
  
// Utility function to print the queue 
public static void Print()
{
    while (queue.Count > 0)
    {
        Console.Write(queue.First.Value + ", ");
        queue.RemoveFirst();
    }
}
  
// Function to reverse the queue 
public static void reversequeue()
{
    Stack<int> stack = new Stack<int>();
    while (queue.Count > 0)
    {
        stack.Push(queue.First.Value);
        queue.RemoveFirst();
    }
    while (stack.Count > 0)
    {
        queue.AddLast(stack.Peek());
        stack.Pop();
    }
}
  
// Driver code 
public static void Main(string[] args)
{
    queue = new LinkedList<int>();
    queue.AddLast(10);
    queue.AddLast(20);
    queue.AddLast(30);
    queue.AddLast(40);
    queue.AddLast(50);
    queue.AddLast(60);
    queue.AddLast(70);
    queue.AddLast(80);
    queue.AddLast(90);
    queue.AddLast(100);
  
    reversequeue();
    Print();
}
}
  
// This code is contributed by Shrikant13


Output:

100, 90, 80, 70, 60, 50, 40, 30, 20, 10

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



This article is attributed to GeeksforGeeks.org

leave a comment

code

0 Comments

load comments

Subscribe to Our Newsletter