Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Reverse a stack using recursion

  • Difficulty Level : Medium
  • Last Updated : 20 Dec, 2021

Write a program to reverse a stack using recursion. You are not allowed to use loop constructs like while, for..etc, and you can only use the following ADT functions on Stack S: 
isEmpty(S) 
push(S) 
pop(S)

The idea of the solution is to hold all values in Function Call Stack until the stack becomes empty. When the stack becomes empty, insert all held items one by one at the bottom of the stack. 
For example, let the input stack be  

    1  <-- top
    2
    3
    4    
First 4 is inserted at the bottom.
    4 <-- top

Then 3 is inserted at the bottom
    4 <-- top    
    3

Then 2 is inserted at the bottom
    4 <-- top    
    3 
    2
     
Then 1 is inserted at the bottom
    4 <-- top    
    3 
    2
    1

So we need a function that inserts at the bottom of a stack using the above given basic stack function.

void insertAtBottom((): First pops all stack items and stores the popped item in function call stack using recursion. And when stack becomes empty, pushes new item and all items stored in call stack.

void reverse(): This function mainly uses insertAtBottom() to pop all items one by one and insert the popped items at the bottom.  

C++




// C++ code to reverse a
// stack using recursion
#include<bits/stdc++.h>
using namespace std;
 
// using std::stack for
// stack implementation
stack<char> st;
 
// initializing a string to store
// result of reversed stack
string ns;
 
// Below is a recursive function
// that inserts an element
// at the bottom of a stack.
void insert_at_bottom(char x)
{
 
    if(st.size() == 0)
    st.push(x);
 
    else
    {
         
        // All items are held in Function Call
        // Stack until we reach end of the stack
        // When the stack becomes empty, the
        // st.size() becomes 0, the above if
        // part is executed and the item is
        // inserted at the bottom
             
        char a = st.top();
        st.pop();
        insert_at_bottom(x);
 
        // push allthe items held in
        // Function Call Stack
        // once the item is inserted
        // at the bottom
        st.push(a);
    }
}
 
// Below is the function that
// reverses the given stack using
// insert_at_bottom()
void reverse()
{
    if(st.size()>0)
    {
         
        // Hold all items in Function
        // Call Stack until we
        // reach end of the stack
        char x = st.top();
        st.pop();
        reverse();
         
        // Insert all the items held
        // in Function Call Stack
        // one by one from the bottom
        // to top. Every item is
        // inserted at the bottom
        insert_at_bottom(x);
    }
}
 
// Driver Code
int main()
{
     
    // push elements into
    // the stack
    st.push('1');
    st.push('2');
    st.push('3');
    st.push('4');
     
    cout<<"Original Stack"<<endl;
     
    // print the elements
    // of original stack
    cout<<"1"<<" "<<"2"<<" "
        <<"3"<<" "<<"4"
        <<endl;
     
    // function to reverse
    // the stack
    reverse();
    cout<<"Reversed Stack"
        <<endl;
     
    // storing values of reversed
    // stack into a string for display
    while(!st.empty())
    {
        char p=st.top();
        st.pop();
        ns+=p;
    }
     
    //display of reversed stack
    cout<<ns[3]<<" "<<ns[2]<<" "
        <<ns[1]<<" "<<ns[0]<<endl;
    return 0;
}
 
// This code is contributed by Gautam Singh
C



// C program to reverse a
// stack using recursion
#include<stdio.h>
#include<stdlib.h>
#define bool int
 
// structure of a stack node
struct sNode
{
    char data;
    struct sNode *next;
};
 
// Function Prototypes
void push(struct sNode** top_ref,
                   int new_data);
int pop(struct sNode** top_ref);
bool isEmpty(struct sNode* top);
void print(struct sNode* top);
 
// Below is a recursive function
// that inserts an element
// at the bottom of a stack.
void insertAtBottom(struct sNode** top_ref,
                                 int item)
{
    if (isEmpty(*top_ref))
        push(top_ref, item);
    else
    {
 
        // Hold all items in Function Call
        // Stack until we reach end of the
        // stack. When the stack becomes
        // empty, the isEmpty(*top_ref)becomes
        // true, the above if part is executed
        // and the item is inserted at the bottom
        int temp = pop(top_ref);
        insertAtBottom(top_ref, item);
 
        // Once the item is inserted
        // at the bottom, push all
        // the items held in Function
        // Call Stack
        push(top_ref, temp);
    }
}
 
// Below is the function that
// reverses the given stack using
// insertAtBottom()
void reverse(struct sNode** top_ref)
{
    if (!isEmpty(*top_ref))
    {
        // Hold all items in Function
        // Call Stack until we
        // reach end of the stack
        int temp = pop(top_ref);
        reverse(top_ref);
 
        // Insert all the items (held in
        // Function Call Stack)
        // one by one from the bottom
        // to top. Every item is
        // inserted at the bottom
        insertAtBottom(top_ref, temp);
    }
}
 
// Driver Code
int main()
{
    struct sNode *s = NULL;
    push(&s, 4);
    push(&s, 3);
    push(&s, 2);
    push(&s, 1);
 
    printf("\n Original Stack ");
    print(s);
    reverse(&s);
    printf("\n Reversed Stack ");
    print(s);
    return 0;
}
 
// Function to check if
// the stack is empty
bool isEmpty(struct sNode* top)
{
    return (top == NULL)? 1 : 0;
}
 
// Function to push an item to stack
void push(struct sNode** top_ref,
                    int new_data)
{
     
    // allocate node
    struct sNode* new_node =
        (struct sNode*) malloc(sizeof(struct sNode));
 
    if (new_node == NULL)
    {
        printf("Stack overflow \n");
        exit(0);
    }
 
    // put in the data
    new_node->data = new_data;
 
    // link the old list
    // off the new node
    new_node->next = (*top_ref);
 
    // move the head to
    // point to the new node
    (*top_ref) = new_node;
}
 
// Function to pop an item from stack
int pop(struct sNode** top_ref)
{
    char res;
    struct sNode *top;
 
    // If stack is empty then error
    if (*top_ref == NULL)
    {
        printf("Stack overflow \n");
        exit(0);
    }
    else
    {
        top = *top_ref;
        res = top->data;
        *top_ref = top->next;
        free(top);
        return res;
    }
}
 
// Function to print a
// linked list
void print(struct sNode* top)
{
    printf("\n");
    while (top != NULL)
    {
        printf(" %d ", top->data);
        top = top->next;
    }
}
Java



// Java code to reverse a
// stack using recursion
import java.util.Stack;
 
class Test {
     
    // using Stack class for
    // stack implementation
    static Stack<Character> st = new Stack<>();
     
    // Below is a recursive function
    // that inserts an element
    // at the bottom of a stack.
    static void insert_at_bottom(char x)
    {
 
        if(st.isEmpty())
            st.push(x);
 
        else
        {
             
            // All items are held in Function
            // Call Stack until we reach end
            // of the stack. When the stack becomes
            // empty, the st.size() becomes 0, the
            // above if part is executed and
            // the item is inserted at the bottom
            char a = st.peek();
            st.pop();
            insert_at_bottom(x);
 
            // push allthe items held
            // in Function Call Stack
            // once the item is inserted
            // at the bottom
            st.push(a);
        }
    }
     
    // Below is the function that
    // reverses the given stack using
    // insert_at_bottom()
    static void reverse()
    {
        if(st.size() > 0)
        {
             
            // Hold all items in Function
            // Call Stack until we
            // reach end of the stack
            char x = st.peek();
            st.pop();
            reverse();
             
            // Insert all the items held
            // in Function Call Stack
            // one by one from the bottom
            // to top. Every item is
            // inserted at the bottom
            insert_at_bottom(x);
        }
    }
     
    // Driver Code
    public static void main(String[] args)
    {
         
        // push elements into
        // the stack
        st.push('1');
        st.push('2');
        st.push('3');
        st.push('4');
         
        System.out.println("Original Stack");
         
        System.out.println(st);
         
        // function to reverse
        // the stack
        reverse();
         
        System.out.println("Reversed Stack");
         
        System.out.println(st);
    }
}
Python3



# Python program to reverse a
# stack using recursion
 
# Below is a recursive function
# that inserts an element
# at the bottom of a stack.
def insertAtBottom(stack, item):
    if isEmpty(stack):
        push(stack, item)
    else:
        temp = pop(stack)
        insertAtBottom(stack, item)
        push(stack, temp)
 
# Below is the function that
# reverses the given stack
# using insertAtBottom()
def reverse(stack):
    if not isEmpty(stack):
        temp = pop(stack)
        reverse(stack)
        insertAtBottom(stack, temp)
 
# Below is a complete running
# program for testing above
# functions.
 
# Function to create a stack.
# It initializes size of stack
# as 0
def createStack():
    stack = []
    return stack
 
# Function to check if
# the stack is empty
def isEmpty( stack ):
    return len(stack) == 0
 
# Function to push an
# item to stack
def push( stack, item ):
    stack.append( item )
 
# Function to pop an
# item from stack
def pop( stack ):
 
    # If stack is empty
    # then error
    if(isEmpty( stack )):
        print("Stack Underflow ")
        exit(1)
 
    return stack.pop()
 
# Function to print the stack
def prints(stack):
    for i in range(len(stack)-1, -1, -1):
        print(stack[i], end = ' ')
    print()
 
# Driver Code
 
stack = createStack()
push( stack, str(4) )
push( stack, str(3) )
push( stack, str(2) )
push( stack, str(1) )
print("Original Stack ")
prints(stack)
 
reverse(stack)
 
print("Reversed Stack ")
prints(stack)
 
# This code is contributed by Sunny Karira
C#



// C# code to reverse a
// stack using recursion
using System;
using System.Collections;
 
public class GFG
{
 
    // using Stack class for
    // stack implementation
    static Stack st = new Stack();
     
    // Below is a recursive function
    // that inserts an element
    // at the bottom of a stack.
    static void insert_at_bottom(char x)
    {
 
        if(st.Count==0)
            st.Push(x);
 
        else
        {
             
            // All items are held in Function
            // Call Stack until we reach end
            // of the stack. When the stack becomes
            // empty, the st.size() becomes 0, the
            // above if part is executed and
            // the item is inserted at the bottom
            char a = (char)st.Peek();
            st.Pop();
            insert_at_bottom(x);
 
            // push all the items held
            // in Function Call Stack
            // once the item is inserted
            // at the bottom
            st.Push(a);
        }
    }
     
    // Below is the function that
    // reverses the given stack using
    // insert_at_bottom()
    static void reverse()
    {
        if(st.Count > 0)
        {
             
            // Hold all items in Function
            // Call Stack until we
            // reach end of the stack
            char x = (char)st.Peek();
            st.Pop();
            reverse();
             
            // Insert all the items held
            // in Function Call Stack
            // one by one from the bottom
            // to top. Every item is
            // inserted at the bottom
            insert_at_bottom(x);
        }
    }
     
    // Driver Code
    public static void Main(String []args)
    {
         
        // push elements into
        // the stack
        st.Push('1');
        st.Push('2');
        st.Push('3');
        st.Push('4');
         
        Console.WriteLine("Original Stack");
         
        foreach (char i in st)
        {
            Console.WriteLine(i);
        }
         
        // function to reverse
        // the stack
        reverse();
         
        Console.WriteLine("Reversed Stack");
        foreach (char i in st)
        {
            Console.WriteLine(i);
        }
    }
 
}
 
// This code is Contributed by Arnab Kundu
Javascript



<script>
 
// JavaScript code to reverse a
// stack using recursion
 
// using Stack class for
// stack implementation
let st = [];
 
// Below is a recursive function
// that inserts an element
// at the bottom of a stack.
function insert_at_bottom(x)
{
    if(st.length==0)
        st.push(x);
    else
    {
        // All items are held in Function
            // Call Stack until we reach end
            // of the stack. When the stack becomes
            // empty, the st.size() becomes 0, the
            // above if part is executed and
            // the item is inserted at the bottom
            let a = st.pop();
            insert_at_bottom(x);
  
            // push allthe items held
            // in Function Call Stack
            // once the item is inserted
            // at the bottom
            st.push(a);
    }
     
     
}
 
// Below is the function that
    // reverses the given stack using
    // insert_at_bottom()
function reverse()
{
    if(st.length > 0)
        {
              
            // Hold all items in Function
            // Call Stack until we
            // reach end of the stack
            let x = st.pop();
            reverse();
              
            // Insert all the items held
            // in Function Call Stack
            // one by one from the bottom
            // to top. Every item is
            // inserted at the bottom
            insert_at_bottom(x);
        }
}
 
// Driver Code
 
// push elements into
// the stack
st.push('1');
st.push('2');
st.push('3');
st.push('4');
 
document.write("Original Stack<br>");
 
document.write(st.join(" ")+"<br>");
 
// function to reverse
// the stack
reverse();
 
document.write("Reversed Stack<br>");
 
document.write(st.join(" "));
 
 
// This code is contributed by avanitrachhadiya2155
 
</script>
Output: 
 Original Stack 
 1  2  3  4 
 Reversed Stack 
 4  3  2  1 
Time Complexity: This approach takes the worst time complexity of O(n^2), 
Please write comments if you find any bug in above code/algorithm, or find other ways to solve the same problem. 
 

My Personal Notes
arrow_drop_up
Previous
Reverse a stack without using extra space in O(n)
Next

Stack | Set 3 (Reverse a string using stack)
Recommended Articles
Page :
Stack | Set 3 (Reverse a string using stack)
08, Feb 14
Sort a stack using recursion
02, Oct 15
Reverse a Doubly linked list using recursion
24, Dec 17
Print Fibonacci Series in reverse order using Recursion
22, Nov 21
C Program to reverse the digits of a number using recursion
12, Oct 20
Sort a stack using a temporary stack
01, Jul 17
Infix to Postfix using different Precedence Values for In-Stack and Out-Stack
22, Nov 18
Find maximum in stack in O(1) without using additional stack
29, Mar 19
Reverse a stack without using extra space in O(n)
01, Oct 17
Print Reverse a linked list using Stack
20, Dec 17
Reverse alternate levels of a perfect binary tree using Stack
26, Mar 19
Reverse the Words of a String using Stack
18, Jun 19
Java Program to Reverse a String using Stack
18, Oct 20
Reverse an array using Stack
17, Jan 21
Reverse a number using stack
01, Aug 17
Program to reverse a linked list using Stack
07, Feb 19
Reversing a Stack with the help of another empty Stack
03, May 21
Stack Permutations (Check if an array is stack permutation of other)
21, Jul 17
Reverse first K elements of the given Stack
02, Feb 22
Python program to reverse a stack
25, Nov 20
Count of unique pairs (i, j) in an array such that sum of A[i] and reverse of A[j] is equal to sum of reverse of A[i] and A[j]
12, Feb 21
Decimal to Binary using recursion and without using power operator
10, Jul 19
Juggler Sequence | Set 2 (Using Recursion)
02, Dec 21
Remove duplicates from a sorted linked list using recursion
19, Apr 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!