Skip to content
Related Articles

Related Articles

Reversing a Stack using two empty Stacks

View Discussion
Improve Article
Save Article
  • Difficulty Level : Basic
  • Last Updated : 24 Aug, 2021

Given a stack S, the task is to reverse the stack S using two additional stacks.

Example:

Input: S={1, 2, 3, 4, 5}
Output: 5 4 3 2 1
Explanation:
The initial stack S:
1→top
2
3
4
5
After reversing it, use two additional stacks:
5→top
4
3
2
1

Input: S={1, 25, 17}
Output: 17 25 1

 

Approach: Follow the steps below to solve the problem:

  1. Create two additional empty stacks, say A and B.
  2. Define a function transfer() that accepts two stacks X and Y as parameters and performs the following operations:
    1. Loop while X is not empty and perform the following operations:
      1. Push the top element of the stack X into Y.
      2. Pop that element from X.
  3. Call transfer(S, A) tos transfers all elements of the stack S to A. (The order of the elements is reversed).
  4. Call transfer(A, B) to transfer all elements of the stack A to B. (The order of the elements is the same as initially in S)
  5. Call transfer(B, S) to transfer all elements of B to S. (The order of the elements is reversed)
  6. Finally, display the stack S.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to transfer elements
// from the stack X to the stack Y
void transfer(stack<int>& X,
              stack<int>& Y)
{
    // Iterate while X is not empty
    while (!X.empty()) {
 
        // Push the top element
        // of X into Y
        Y.push(X.top());
 
        // Pop from X
        X.pop();
    }
}
 
// Function to display the
// contents of the stack S
void display(stack<int> S)
{
    // Iterate while S is
    // not empty
    while (!S.empty()) {
 
        // Print the top
        // element of the stack S
        cout << S.top() << " ";
 
        // Pop from S
        S.pop();
    }
    cout << endl;
}
 
// Function to reverse a stack using two stacks
void reverseStackUsingTwoStacks(stack<int>& S)
{
    // Two additional stacks
    stack<int> A, B;
 
    // Transfer all elements
    // from the stack S to A
    transfer(S, A);
 
    // Transfer all elements
    // from the stack A to B
    transfer(A, B);
 
    // Transfer all elements
    // from the stack B to S
    transfer(B, S);
 
    // Print the contents of S
    display(S);
}
// Driver Code
int main()
{
    // Input
    stack<int> S;
    S.push(5);
    S.push(4);
    S.push(3);
    S.push(2);
    S.push(1);
 
    // Function call
    reverseStackUsingTwoStacks(S);
 
    return 0;
}

Java




// Java program for the above approach
import java.util.Stack;
public class GFG
{
 
    // Function to transfer elements
    // from the stack X to the stack Y
    static void transfer(Stack<Integer> X, Stack<Integer> Y)
    {
        // Iterate while X is not empty
        while (!X.empty())
        {
 
            // Push the top element
            // of X into Y
            Y.push(X.peek());
 
            // Pop from X
            X.pop();
        }
    }
 
    // Function to display the
    // contents of the stack S
    static void display(Stack<Integer> S)
    {
        // Iterate while S is
        // not empty
        while (!S.empty()) {
 
            // Print the top
            // element of the stack S
            System.out.print(S.peek() + " ");
 
            // Pop from S
            S.pop();
        }
        System.out.println();
    }
 
    // Function to reverse a stack using two stacks
    static void reverseStackUsingTwoStacks(Stack<Integer> S)
    {
        // Two additional stacks
        Stack<Integer> A = new Stack<>();
        Stack<Integer> B = new Stack<>();
 
        // Transfer all elements
        // from the stack S to A
        while (!S.empty())
            A.push(S.pop());
 
        // Transfer all elements
        // from the stack A to B
        while (!A.empty())
            B.push(A.pop());
 
        // Transfer all elements
        // from the stack B to S
        while (!B.empty())
            S.push(B.pop());
 
        // Print the contents of S
        display(S);
    }
 
    // Driver code
    public static void main(String[] args)
    {
       
      // Given Input
      // Input
        Stack<Integer> S = new Stack<>();
        S.push(5);
        S.push(4);
        S.push(3);
        S.push(2);
        S.push(1);
 
        // Function call
        reverseStackUsingTwoStacks(S);
    }
}
 
// This code is contributed by abhinavjain194

Python3




# Python3 program for the above approach
 
# Function to display the
# contents of the stack S
def display(S):
   
    # Iterate while S is
    # not empty
    while len(S) > 0:
 
        # Print the top
        # element of the stack S
        print(S[-1], end = " ")
 
        # Pop from S
        S.pop()
    print()
 
# Function to reverse a stack using two stacks
def reverseStackUsingTwoStacks(S):
   
    # Two additional stacks
    A = []
    B = []
        
    # Transfer all elements
    # from the stack S to A
    while len(S) > 0:
        A.append(S[-1])
        S.pop()
        
    # Transfer all elements
    # from the stack A to B
    while len(A) > 0:
        B.append(A[-1])
        A.pop()
        
    # Transfer all elements
    # from the stack B to S
    while len(B) > 0:
        S.append(B[-1])
        B.pop()
        
    # Print the contents of S
    display(S)
 
# Given Input
# Input
S = []
S.append(5)
S.append(4)
S.append(3)
S.append(2)
S.append(1)
 
# Function call
reverseStackUsingTwoStacks(S)
 
# This code is contributed by suresh07.

C#




// C# program for the above approach
using System;
using System.Collections;
class GFG {
     
    // Function to transfer elements
    // from the stack X to the stack Y
    static void transfer(Stack X, Stack Y)
    {
        // Iterate while X is not empty
        while (X.Count > 0)
        {
  
            // Push the top element
            // of X into Y
            Y.Push(X.Peek());
  
            // Pop from X
            X.Pop();
        }
    }
  
    // Function to display the
    // contents of the stack S
    static void display(Stack S)
    {
        // Iterate while S is
        // not empty
        while (S.Count > 0) {
  
            // Print the top
            // element of the stack S
            Console.Write(S.Peek() + " ");
  
            // Pop from S
            S.Pop();
        }
        Console.WriteLine();
    }
  
    // Function to reverse a stack using two stacks
    static void reverseStackUsingTwoStacks(Stack S)
    {
        // Two additional stacks
        Stack A = new Stack();
        Stack B = new Stack();
  
        // Transfer all elements
        // from the stack S to A
        while (S.Count > 0)
            A.Push(S.Pop());
  
        // Transfer all elements
        // from the stack A to B
        while (A.Count > 0)
            B.Push(A.Pop());
  
        // Transfer all elements
        // from the stack B to S
        while (B.Count > 0)
            S.Push(B.Pop());
  
        // Print the contents of S
        display(S);
    }
 
  static void Main() {
    // Given Input
    // Input
    Stack S = new Stack();
    S.Push(5);
    S.Push(4);
    S.Push(3);
    S.Push(2);
    S.Push(1);
 
    // Function call
    reverseStackUsingTwoStacks(S);
  }
}
 
// This code is contributed by divyesh072019.

Javascript




<script>
    // Javascript program for the above approach
   
    // Function to display the
    // contents of the stack S
    function display(S)
    {
        // Iterate while S is
        // not empty
        while (S.length > 0) {
   
            // Print the top
            // element of the stack S
            document.write(S[S.length - 1] + " ");
   
            // Pop from S
            S.pop();
        }
        document.write("</br>");
    }
   
    // Function to reverse a stack using two stacks
    function reverseStackUsingTwoStacks(S)
    {
        // Two additional stacks
        let A = [];
        let B = [];
           
        // Transfer all elements
        // from the stack S to A
        while (S.length > 0)
        {
            A.push(S[S.length - 1]);
            S.pop();
        }
           
        // Transfer all elements
        // from the stack A to B
        while (A.length > 0)
        {
            B.push(A[A.length - 1]);
            A.pop();
        }
           
        // Transfer all elements
        // from the stack B to S
        while (B.length > 0)
        {
            S.push(B[B.length - 1]);
            B.pop();
        }
           
        // Print the contents of S
        display(S);
    }
     
    // Given Input
    // Input
    let S = [];
    S.push(5);
    S.push(4);
    S.push(3);
    S.push(2);
    S.push(1);
  
    // Function call
    reverseStackUsingTwoStacks(S);
     
    // This code is contributed by mukesh07.
</script>

 
 

Output: 

5 4 3 2 1

 

 

Time Complexity: O(N)
Auxiliary Space: O(N)

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!