C Program to Reverse a Stack using Recursion

Last Updated : 26 Oct, 2022

Write a program to reverse a stack using recursion, without using any loop.

Example:

Input: elements present in stack from top to bottom 1 2 3 4
Output: 4 3 2 1

Input: elements present in stack from top to bottom 1 2 3
Output: 3 2 1

Reverse a stack using Recursion

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.

Illustration:

Below is the illustration of the above approach

Let given stack be

1

2

3

4



After all calls of reverse, 4 will be passed to function insert at bottom, after that 4 will pushed to the stack when stack is empty



4

Then 3 will be passed to function insert at bottom , it will check if the stack is empty or not if not then pop all the elements back and insert 3 and then push other elements back.

4

3

Then 2 will be passed to function insert at bottom , it will check if the stack is empty or not if not then pop all the elements back and insert 2 and then push other elements back.

4

3

2

Then 1 will be passed to function insert at bottom , it will check if the stack is empty or not if not then pop all the elements back and insert 1 and then push other elements back.

4

3

2

1

Follow the steps mentioned below to implement the idea:

Create a stack and push all the elements in it.
Call reverse(), which will pop all the elements from the stack and pass the popped element to function insert_at_bottom()
Whenever insert_at_bottom() is called it will insert the passed element at the bottom of the stack.
Print the stack

Below is the implementation of the above approach:

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(" 
 Original Stack "); 
    print(s); 
    reverse(&s); 
    printf(" 
 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  
"); 
        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  
"); 
        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(" 
"); 
    while (top != NULL) { 
        printf(" %d ", top->data); 
        top = top->next; 
    } 
}
 
  

Output

Original Stack  1 2 3 4   Reversed Stack  1 2 3 4

Time Complexity: O(N²).
Auxiliary Space: O(N) use of Stack

C Program to reverse the digits of a number using recursion

kartik

Improve

Article Tags :

Practice Tags :

C Program to Reverse a Stack using Recursion

Reverse a stack using Recursion

C

Similar Reads