Open in App
Not now

Reverse a Stack using Queue

• Difficulty Level : Medium
• Last Updated : 22 Dec, 2022

Given a stack, the task is to reverse the stack using the queue data structure.

Examples:

Input: Stack: (Top to Bottom) [10 -> 20 -> 30 -> 40]
Output: Stack: (Top to Bottom) [40 -> 30 -> 20 -> 10]

Input:  Stack: [6 -> 5 -> 4]
Output: Stack: [4 -> 5 -> 6]

Approach: The problem can be solved based on the following idea:

The stack follows LIFO order and the queue follows FIFO order. So, if we push all stack elements into queue and then push it back into the stack it will be reversed.

Illustration:

Consider Stack: [40 -> 30 -> 20 -> 10]

Step 1:

• Stack: (Bottom to Top) [40 -> 30 -> 20 -> 10]
Queue: (Front to Rear) Empty

Step 2:

• Stack: (Bottom to Top) [40 -> 30 -> 20]
Queue: (Front to Rear) 10

Step 3:

• Stack: (Bottom to Top) [40 -> 30]
Queue: (Front to Rear) [10 -> 20]

Step 4:

• Stack: (Bottom to Top) [40]
Queue: (Front to Rear) [10 -> 20 -> 30]

Step 5:

• Stack: (Bottom to Top) Empty
Queue: (Front to Rear) [10 -> 20 -> 30 -> 40]

Step 6:

• Stack: (Bottom to Top) [10]
Queue: (Front to Rear) [20 -> 30 -> 40]

Step 7:

• Stack: (Bottom to Top) [10 -> 20]
Queue: (Front to Rear) [30 -> 40]

Step 8:

• Stack: (Bottom to Top) [10 -> 20 -> 30]
Queue: (Front to Rear) [40]

Step 9:

• Stack: (Bottom to Top) [10 -> 20 -> 30 -> 40]
Queue: (Front to Rear) Empty

Follow the steps to solve the problem:

• Pop Elements one by one from the stack.
• Enqueue every popped element into the queue.
• Do it till the stack is empty.
• Then, Dequeue elements one by one from the queue.
• Push every dequeued element into the stack.
• Do it till the queue is empty.
• The stack is now reversed.

Below is the implementation for the above approach:

C++

 `// C++ code to reverse a stack using queue` `#include ` `using` `namespace` `std;`   `void` `reverse(stack<``int``>& stk)` `{` `    ``queue<``int``> qu;`   `    ``// Enqueue all into queue` `    ``while` `(!stk.empty()) {` `        ``qu.push(stk.top());` `        ``stk.pop();` `    ``}`   `    ``// Now stack is empty thus push all` `    ``// elements back into the` `    ``// stack - FIFO order` `    ``while` `(!qu.empty()) {` `        ``stk.push(qu.front());` `        ``qu.pop();` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``stack<``int``> stk;` `    ``stk.push(40);` `    ``stk.push(30);` `    ``stk.push(20);` `    ``stk.push(10);`   `    ``// Function Call` `    ``reverse(stk);`   `    ``// 40 30 20 10 (top to bottom)` `    ``cout << ``"After Reverse : (Top to Bottom)"` `         ``<< ``"\n"``;` `    ``while` `(!stk.empty()) {` `        ``cout << stk.top() << ``" "``;` `        ``stk.pop();` `    ``}` `    ``cout << ``"\n"``;`   `    ``return` `0;` `}`

Java

 `// Java code to reverse a stack using queue`   `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``static` `void` `reverse(Stack stk)` `    ``{` `        ``Queue qu = ``new` `LinkedList<>();`   `        ``// Enqueue all into queue` `        ``while` `(!stk.isEmpty()) {` `            ``qu.add(stk.peek());` `            ``stk.pop();` `        ``}`   `        ``// Now stack is empty thus push all elements back` `        ``// into the stack - FIFO order` `        ``while` `(!qu.isEmpty()) {` `            ``stk.push(qu.peek());` `            ``qu.poll();` `        ``}` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``Stack stk = ``new` `Stack<>();`   `        ``stk.push(``40``);` `        ``stk.push(``30``);` `        ``stk.push(``20``);` `        ``stk.push(``10``);`   `        ``// Function call` `        ``reverse(stk);`   `        ``// 40 30 20 10 (top to bottom)` `        ``System.out.println(` `            ``"After Reverse : (Top to Bottom)"``);`   `        ``while` `(!stk.isEmpty()) {` `            ``System.out.print(stk.peek() + ``" "``);` `            ``stk.pop();` `        ``}` `        ``System.out.println();` `    ``}` `}`   `// This code is contributed by lokeshmvs21.`

Python3

 `# Python code to reverse a stack using queue` `from` `collections ``import` `deque`   `def` `reverse(stack):` `    ``queue ``=` `deque()` `    `  `    ``# Enqueue all into queue` `    ``while` `stack !``=` `[]:` `        ``queue.append(stack.pop())` `    `  `    ``# Now stack is empty thus  append all` `    ``# elements back into the` `    ``# stack - FIFO order` `    ``while` `queue:` `        ``stack.append(queue.popleft())` `    ``return` `stack`   `stack ``=` `[]` `stack.append(``40``) ` `stack.append(``30``) ` `stack.append(``20``) ` `stack.append(``10``) `   ` ``# Function Call` `stack ``=` `reverse(stack) `   ` ``# 40 30 20 10 (top to bottom)` `print``(``"After Reverse : (Top to Bottom)"``)` `while` `stack !``=` `[]:` `    ``print``(stack[``-``1``], end``=``" "``) ` `    ``stack.pop() ` `    `  `    ``# This code is contributed by hardikkhuswaha.`

C#

 `// C# code to reverse a stack using queue`   `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG {`   `    ``static` `void` `Reverse(Stack<``int``> stk)` `    ``{` `        ``Queue<``int``> qu = ``new` `Queue<``int``>();`   `        ``// Enqueue all into queue` `        ``while` `(stk.Count > 0) {` `            ``qu.Enqueue(stk.Peek());` `            ``stk.Pop();` `        ``}`   `        ``// Now stack is empty thus push all elements back` `        ``// into the stack - FIFO order` `        ``while` `(qu.Count > 0) {` `            ``stk.Push(qu.Peek());` `            ``qu.Dequeue();` `        ``}` `    ``}`   `    ``static` `public` `void` `Main()` `    ``{`   `        ``// Code` `        ``Stack<``int``> stk = ``new` `Stack<``int``>();`   `        ``stk.Push(40);` `        ``stk.Push(30);` `        ``stk.Push(20);` `        ``stk.Push(10);`   `        ``// Function call` `        ``Reverse(stk);`   `        ``// 40 30 20 10 (top to bottom)` `        ``Console.WriteLine(` `            ``"After Reverse : (Top to Bottom)"``);`   `        ``while` `(stk.Count > 0) {` `            ``Console.Write(stk.Peek() + ``" "``);` `            ``stk.Pop();` `        ``}` `        ``Console.WriteLine();` `    ``}` `}`   `// This code is contributed by lokesh.`

Javascript

 `function` `reverse(stk) {` `  ``let qu = [];`   `  ``// Enqueue all into queue` `  ``while` `(stk.length > 0) {` `    ``qu.push(stk.pop());` `  ``}`   `  ``// Now stack is empty, so push all` `  ``// elements back into the stack` `  ``// in FIFO order` `  ``while` `(qu.length > 0) {` `    ``stk.push(qu.shift());` `  ``}` `}`   `// Test the function` `let stk = [10, 20, 30, 40];`   `// Function Call` `reverse(stk);`   `// 40 30 20 10 (top to bottom)` `console.log(``"After Reverse : (Top to Bottom)"``);` `while` `(stk.length > 0) {` `  ``console.log(stk.pop() + ``" "``);` `}`   `// This code is contributed by aadityamaharshi21.`

Output

```After Reverse : (Top to Bottom)
40 30 20 10 ```

Time Complexity: O(N), As we are popping out N elements, then only pushing N elements. N+N operations.
Auxiliary Space: O(N), As we are using an Extra Queue of N Space.

Related articles:

My Personal Notes arrow_drop_up
Related Articles