Reversing a Queue

Try it on GfG Practice

You are given a queue Q, and your task is to reverse the elements of the queue. You are only allowed to use the following standard queue operations:

1. enqueue(x): Add an item x to the rear of the queue.
2. dequeue(): Remove an item from the front of the queue.
3. empty(): Check if the 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: q = [1, 2, 3, 4, 5]
Output: q = [5, 4, 3, 2, 1]

Reversing a Queue using Stack

To reverse the queue, we can use a stack data structure that follows the LIFO (Last In, First Out) principle. By storing the elements in such a structure, we can ensure that when the elements are re-inserted into the queue, they will appear in reverse order.

Follow the below steps to implement the idea:

• Pop the elements from the queue and insert into the stack now topmost element of the stack is the last element of the queue.
• Pop the elements of the stack to insert back into the queue the last element is the first one to be inserted into the queue.

#include <iostream>
#include <queue>
#include <stack>
using namespace std;

void print(queue<int>& q)
{
    while (!q.empty()) {
        cout << q.front() << " ";
        q.pop();
    }
}

// Function to reverse the queue
void reverseQueue(queue<int>& q)
{
    stack<int> s;
    while (!q.empty()) {
        s.push(q.front());
        q.pop();
    }
    while (!s.empty()) {
        q.push(s.top());
        s.pop();
    }
}

int main()
{
    queue<int> q;
    q.push(10);
    q.push(20);
    q.push(30);
    q.push(40);
    q.push(50);
    q.push(60);
    q.push(70);
    q.push(80);
    q.push(90);
    q.push(100);

    reverseQueue(q);
    print(q);
}

// Importing necessary libraries
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class Main {
    
    // Function to print the queue
    public static void print(Queue<Integer> q) {
        while (!q.isEmpty()) {
            System.out.print(q.poll() + " ");
        }
    }

    // Function to reverse the queue
    public static void reverseQueue(Queue<Integer> q) {
        Stack<Integer> s = new Stack<>();
        while (!q.isEmpty()) {
            s.push(q.poll());
        }
        while (!s.isEmpty()) {
            q.add(s.pop());
        }
    }

    public static void main(String[] args) {
        Queue<Integer> q = new LinkedList<>();
        q.add(10);
        q.add(20);
        q.add(30);
        q.add(40);
        q.add(50);
        q.add(60);
        q.add(70);
        q.add(80);
        q.add(90);
        q.add(100);

        reverseQueue(q);
        print(q);
    }
}

# Function to print the queue
from queue import Queue

# Function to print the queue
def print_queue(q):
    while not q.empty():
        print(q.get(), end=' ')

# Function to reverse the queue
def reverse_queue(q):
    s = []
    while not q.empty():
        s.append(q.get())
    while s:
        q.put(s.pop())

if __name__ == '__main__':
    q = Queue()
    q.put(10)
    q.put(20)
    q.put(30)
    q.put(40)
    q.put(50)
    q.put(60)
    q.put(70)
    q.put(80)
    q.put(90)
    q.put(100)

    reverse_queue(q)
    print_queue(q)

// Importing necessary libraries
using System;
using System.Collections.Generic;

class Program {
    
    // Function to print the queue
    static void Print(Queue<int> q) {
        while (q.Count > 0) {
            Console.Write(q.Dequeue() + " ");
        }
    }

    // Function to reverse the queue
    static void ReverseQueue(Queue<int> q) {
        var s = new Stack<int>();
        while (q.Count > 0) {
            s.Push(q.Dequeue());
        }
        while (s.Count > 0) {
            q.Enqueue(s.Pop());
        }
    }

    static void Main() {
        Queue<int> q = new Queue<int>();
        q.Enqueue(10);
        q.Enqueue(20);
        q.Enqueue(30);
        q.Enqueue(40);
        q.Enqueue(50);
        q.Enqueue(60);
        q.Enqueue(70);
        q.Enqueue(80);
        q.Enqueue(90);
        q.Enqueue(100);

        ReverseQueue(q);
        Print(q);
    }
}

// Function to print the queue
function print(q) {
    while (q.length > 0) {
        console.log(q.shift() + ' ');
    }
}

// Function to reverse the queue
function reverseQueue(q) {
    let s = [];
    while (q.length > 0) {
        s.push(q.shift());
    }
    while (s.length > 0) {
        q.push(s.pop());
    }
}

let q = [];
q.push(10);
q.push(20);
q.push(30);
q.push(40);
q.push(50);
q.push(60);
q.push(70);
q.push(80);
q.push(90);
q.push(100);

reverseQueue(q);
print(q);

100 90 80 70 60 50 40 30 20 10 

Time Complexity: O(n), As we need to insert all the elements in the stack and later to the queue.
Auxiliary Space: O(n), Use of stack to store values. 

Reversing a Queue using recursion

Instead of explicitly using stack goal can be achieved using recursion (recursion at backend will itself maintain stack).

Recursively perform the following steps:

• If the queue size is 0 return.
• Else pop and store the front element and recur for remaining queue.
• push the current element in the queue.

Refer Reversing a queue using recursion for more