Invertir una cola

Proporcione un algoritmo para invertir una cola Q. Solo se permiten las siguientes operaciones estándar en la cola. 

1. enqueue(x) : Agrega un elemento x al final de la cola.
2. dequeue() : elimina un elemento del frente de la cola.
3. vacío(): comprueba si una cola está vacía o no.

Ejemplos: 

// 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 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 program to reverse a queue
from collections import deque
 
# Function to reverse the queue
 
 
def reversequeue(queue):
    Stack = []
 
    while (queue):
        Stack.append(queue[0])
        queue.popleft()
 
    while (len(Stack) != 0):
        queue.append(Stack[-1])
        Stack.pop()
 
 
# Driver code
if __name__ == '__main__':
    queue = deque([10, 20, 30, 40, 50, 60, 70, 80, 90, 100])
 
    reversequeue(queue)
    print(queue)
 
# This code is contributed by PranchalK

// 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

<script>
    // Javascript program to reverse a Queue
     
    let queue = [];
   
    // Utility function to print the queue
    function Print()
    {
        while (queue.length > 0) {
            document.write( queue[0] + ", ");
            queue.shift();
        }
    }
   
    // Function to reverse the queue
    function reversequeue()
    {
        let stack = [];
        while (queue.length > 0) {
            stack.push(queue[0]);
            queue.shift();
        }
        while (stack.length > 0) {
            queue.push(stack[stack.length - 1]);
            stack.pop();
        }
    }
     
    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();
    Print();
     
</script>

// 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>& q)
{
    // base case
    if (q.size() == 0)
        return;
    // storing front(first element) of queue
    int fr = q.front();
 
    // removing front
    q.pop();
 
    // asking recursion to reverse the
    // leftover queue
    reverseQueue(q);
 
    // placing first element
    // at its correct position
    q.push(fr);
}
 
// 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);
}
// This code is contributed by Nakshatra Chhillar