反转队列

给出一个倒转队列 Q 的算法。队列上只允许执行以下标准操作。

1. enqueue(x) ：将项目 x 添加到队列的尾部。
2. dequeue() ：从队列前面删除一个项目。
3. empty() ：检查队列是否为空。

例子：

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。

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]

方法：为了反转队列，一种方法可能是将队列的元素存储在临时数据结构中，这样如果我们重新插入队列中的元素，它们就会以相反的顺序插入。所以现在我们的任务是选择可以达到目的的数据结构。根据该方法，数据结构应该具有“后进先出”的属性，因为要插入数据结构中的最后一个元素实际上应该是反向队列的第一个元素。堆栈可以帮助解决这个问题。这将是一个两步过程：

1. 从队列中弹出元素并插入堆栈。 （栈顶元素是队列的最后一个元素）
2. 弹出堆栈的元素以插入回队列。 （最后一个元素是第一个插入队列的元素）

C++

// CPP program to reverse a Queue
#include 
using namespace std;
 
// Utility function to print the queue
void Print(queue& Queue)
{
    while (!Queue.empty()) {
        cout << Queue.front() << " ";
        Queue.pop();
    }
}
 
// Function to reverse the queue
void reverseQueue(queue& Queue)
{
    stack Stack;
    while (!Queue.empty()) {
        Stack.push(Queue.front());
        Queue.pop();
    }
    while (!Stack.empty()) {
        Queue.push(Stack.top());
        Stack.pop();
    }
}
 
// Driver code
int main()
{
    queue 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 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 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();
        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 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 stack = new Stack();
    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();
    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

Javascript

    // 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();
     

输出：

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

复杂度分析：

• 时间复杂度： O(n)。
  因为我们需要将堆栈中的所有元素插入到队列中。
• 辅助空间： O(N)。
  使用堆栈来存储值。