Sort Stack using Recursion

A stack is a linear data structure that operates on the Last In First Out (LIFO) principle. This indicates that the last thing added to the stack is deleted first. The alternate word for a stack is LIFO, which refers to the order in which items are removed from it (last in, first out). This form of structure is called a "stack" because it resembles a stack of real goods placed on top of each other. This structure makes it simple to remove one item from the top of the stack, but removing an item from the bottom of the stack may need to remove numerous other things first. A peek action may also provide access to the top of the stack without altering it.

Sorting a stack is useful for various tasks, including memory management, maintaining the context of a process in the event of an interrupt, and other high-priority tasks. Although we shall see the recursive approach here, sorting may also be done iteratively.

Operations in Stack

In a stack, we can perform the following operations, such as:

Push(): Pushes an element into the stack
Pop(): Pops out the top element of the stack
Top(): Returns the top element of the stack
Size(): Returns the size of the stack

A stack is a very useful and crucial data structure that is employed in memory management and process flow scheduling. The program counter is one of the most important applications of the stack because it saves the context of a processor code from stacking if it has to transition to a new process so that it may return to the old process and finish it when the new process is completed.

Recursion is one of the most significant algorithms because if we can solve a smaller work, we can almost certainly solve the entire project utilizing the smaller jobs. Recursion is a term that refers to the act of calling oneself. It has a base case, which is the major case, in which it handles the smaller problem scenario before calling itself for the minor sections. It uses the fact that while we are standing in a certain state, we presume that our recursive function has done processing for smaller responses, which we can now combine to solve our present state.

Java Code

Let's write a java code to sort a stack using recursion.

import java.util.Arrays;
import java.util.List;
import java.util.Stack;
import java.util.Scanner;
 
class Main
{
    // Insert the given key into the sorted stack while maintaining its
    // sorted order. This is similar to the recursive insertion sort routine.
    public static void sortedInsert(Stack<Integer> stack, int key)
    {
        // base case: if the stack is empty or
        // the key is greater than all elements in the stack
        if (stack.isEmpty() || key > stack.peek())
        {
            stack.push(key);
            return;
        }
 
        /* We reach here when the key is smaller than the top element */
 
        // remove the top element
        int top = stack.pop();
 
        // recur for the remaining elements in the stack
        sortedInsert(stack, key);
 
        // insert the popped element back into the stack
        stack.push(top);
    }
 
    // Recursive method to sort a stack
    public static void sortStack(Stack<Integer> stack)
    {
        // base case: stack is empty
        if (stack.isEmpty()) {
            return;
        }
 
        // remove the top element
        int top = stack.pop();
 
        // recur for the remaining elements in the stack
        sortStack(stack);
 
        // insert the popped element back into the sorted stack
        sortedInsert(stack, top);
    }
 
    public static void main(String[] args)
    {
        
         // creating a object of the inbuilt class Stack named stack
        Stack<Integer> stack = new Stack<>();
        Scanner scan = new Scanner(System.in);
        char ch;
        /**  Print all the options to select from**/
        do    
        {
            System.out.println("\nSelect one of the operations::\n");
            System.out.println("1. To insert a new value in the Stack Data Structure.");
            System.out.println("2. To display the data inside of the Stack Data Structure.");
            System.out.println("3. To perform Sorting(via Recursion) on the Stack Data Structure.");
 
            int choice = scan.nextInt();            
            switch (choice)
            {
            case 1 : 
                System.out.println("Enter integer element to insert");
                stack.push(scan.nextInt());                     
                break;                          
            case 2 : 
                System.out.println("Stack:: "+stack);
                
                break;                                          
            case 3 : 
                System.out.println("Sort done.");
                sortStack(stack);
                break;     
            default : 
                System.out.println("Wrong Entry \n ");
                break;   
            }
            System.out.println("\nDo you want to continue (Type y or n) \n");
            ch = scan.next().charAt(0);                        
        } while (ch == 'Y'|| ch == 'y');
    }
}

Output

Above java code gives the following output.

Select one of the operations::

1. To insert a new value in the Stack Data Structure.
2. To display the data inside of the Stack Data Structure.
3. To perform sorting (via Recursion) on the Stack Data Structure.
1
Enter integer element to insert
45

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new value in the Stack Data Structure.
2. To display the data inside of the Stack Data Structure.
3. To perform sorting (via Recursion) on the Stack Data Structure.
1
Enter integer element to insert
32

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new value in the Stack Data Structure.
2. To display the data inside of the Stack Data Structure.
3. To perform sorting (via Recursion) on the Stack Data Structure.
1
Enter integer element to insert
98

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new value in the Stack Data Structure.
2. To display the data inside of the Stack Data Structure.
3. To perform sorting (via Recursion) on the Stack Data Structure.
1
Enter integer element to insert
22

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new value in the Stack Data Structure.
2. To display the data inside of the Stack Data Structure.
3. To perform sorting (via Recursion) on the Stack Data Structure.
1
Enter integer element to insert
49

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new value in the Stack Data Structure.
2. To display the data inside of the Stack Data Structure.
3. To perform sorting (via Recursion) on the Stack Data Structure.
1
Enter integer element to insert
13

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new value in the Stack Data Structure.
2. To display the data inside of the Stack Data Structure.
3. To perform sorting (via Recursion) on the Stack Data Structure.
1 
Enter integer element to insert
36

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new value in the Stack Data Structure.
2. To display the data inside of the Stack Data Structure.
3. To perform sorting (via Recursion) on the Stack Data Structure.
1
Enter integer element to insert
54

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new value in the Stack Data Structure.
2. To display the data inside of the Stack Data Structure.
3. To perform sorting (via Recursion) on the Stack Data Structure.
1
Enter integer element to insert
102

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new value in the Stack Data Structure.
2. To display the data inside of the Stack Data Structure.
3. To perform sorting (via Recursion) on the Stack Data Structure.
1
Enter integer element to insert
506

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new value in the Stack Data Structure.
2. To display the data inside of the Stack Data Structure.
3. To perform sorting (via Recursion) on the Stack Data Structure.
2
Stack:: [45, 32, 98, 22, 49, 13, 36, 54, 102, 506]

Do you want to continue (Type y or n) 

y

Select one of the operations::

1. To insert a new value in the Stack Data Structure.
2. To display the data inside of the Stack Data Structure.
3. To perform sorting (via Recursion) on the Stack Data Structure.
3
Sort done.

Do you want to continue (Type y or n) 

y

Select one of the operations::
1. To insert a new value in the Stack Data Structure.
2. To display the data inside of the Stack Data Structure.
3. To perform sorting (via Recursion) on the Stack Data Structure.
2
Stack:: [13, 22, 32, 36, 45, 49, 54, 98, 102, 506]

Do you want to continue (Type y or n) 

n

In this way, we have written Java code to perform the sort operation on the stack data structure. There are three functions written for the stack data structure one is to add a new node in the stack data structure, the second one is to display all the content present in the stack data structure, and third and the last function is to perform the sort operation on the stack data structure.

The user first adds sufficient data in the stack data structure. Once the nodes are added successfully, the sort operation is performed on the stack data structure by selecting the third option from the menu displayed after each operation which will call the sort() function written in the code to which pass the object of the stack data structure as a parameter.

After the successful completion of the sort operation, the user can confirm the result of the sort operation by displaying the values of the nodes in the stack data structure by selecting the second option from the user. Once all the operations are done, the user can exit the code by entering the 'n' or 'N' character.

C++ Code

Now let's write a C++ code to sort a stack using recursion.

#include <iostream>
#include <stack>
#include <vector>
using namespace std;
 
// Insert the given key into the sorted stack while maintaining its sorted order.
// This is similar to the recursive insertion sort routine
void sortedInsert(stack<int> &stack, int key)
{
    // base case: if the stack is empty or
    // the key is greater than all elements in the stack
    if (stack.empty() || key > stack.top())
    {
        stack.push(key);
        return;
    }
 
    /* We reach here when the key is smaller than the top element */
 
    // remove the top element
    int top = stack.top();
    stack.pop();
 
    // recur for the remaining elements in the stack
    sortedInsert(stack, key);
 
    // insert the popped element back into the stack
    stack.push(top);
}
 
// Recursive method to sort a stack
void sortstack(stack<int> &stack)
{
    // base case: stack is empty
    if (stack.empty()) {
        return;
    }
 
    // remove the top element
    int top = stack.top();
    stack.pop();
 
    // recur for the remaining elements in the stack
    sortstack(stack);
 
    // insert the popped element back into the sorted stack
    sortedInsert(stack, top);
}
 
void printStack(stack<int> stack)
{
    while (!stack.empty())
    {
        cout << stack.top() << " ";
        stack.pop();
    }
    cout << endl;
}
 
int main()
{
    stack<int> stack;

    int data;
    char ch;
        /*  Perform tree operations  */
        do    
        {
            cout<<"\nSelect one of the operations::"<<endl;
            cout<<"1. To insert a new node in the Stack Data Structure."<<endl;
            cout<<"2. To display the nodes of the Stack Data Structure."<<endl;
            cout<<"3. To perform sorting on the Stack Data Structure."<<endl;
             
            int choice;
            cin>>choice;            
            switch (choice)
            {
            case 1 : 
                cout<<"Enter the value to be inserted"<<endl;
                cin>>data;
                stack.push(data);                
                break;                          
            case 2 : 
                cout<<"Contents of the stack are::"<<endl;
                printStack(stack);
                break; 
            case 3 : 
                cout<<"Sort done sucessfully."<<endl;
                sortstack(stack);
                break;
            default : 
                cout<<"Wrong Entry \n ";
                break;   
            }
 
            cout<<"\nDo you want to continue (Type y or n) \n";
            cin>>ch;                        
        } while (ch == 'Y'|| ch == 'y');
    return 0;       
}  // end of main function

Output

The above C++ code gives the following output.

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform sorting on the Stack Data Structure.
1
Enter the value to be inserted
45

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform sorting on the Stack Data Structure.
1
Enter the value to be inserted
32

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform sorting on the Stack Data Structure.
1
Enter the value to be inserted
97 

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform sorting on the Stack Data Structure.
1
Enter the value to be inserted
40

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform sorting on the Stack Data Structure.
1
Enter the value to be inserted
21

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform sorting on the Stack Data Structure.
1
Enter the value to be inserted
67

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform sorting on the Stack Data Structure.
1
Enter the value to be inserted
30

Do you want to continue (Type y or n) 
y
Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform sorting on the Stack Data Structure.
1
Enter the value to be inserted
505

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform sorting on the Stack Data Structure.
1
Enter the value to be inserted
672

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform sorting on the Stack Data Structure.
1
Enter the value to be inserted
341

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform sorting on the Stack Data Structure.
1
Enter the value to be inserted
231

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform sorting on the Stack Data Structure.
2
Contents of the stack are::
231 341 672 505 30 67 21 40 97 32 45 

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform sorting on the Stack Data Structure.
3
Sort did successfully.

Do you want to continue (Type y or n) 
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform sorting on the Stack Data Structure.
2
Contents of the stack are::
672 505 341 231 97 67 45 40 32 30 21 

Do you want to continue (Type y or n) 
n

In this way, we have written C++ code to perform the sort operation on the stack data structure. There are three functions written for the stack data structure one is to add a new node in the stack data structure, the second one is to display all the content present in the stack data structure, and third and the last function is to perform the sort operation on the stack data structure.

C Code

Now let's write a simple C code to Sort a stack using recursion.

// C program to sort a stack using recursion
#include <stdio.h>
#include <stdlib.h>

// Stack is represented using linked list
struct stack {
	int data;
	struct stack* next;
};

// Utility function to initialize stack
void initStack(struct stack** s) { *s = NULL; }

// Utility function to check if stack is empty
int isEmpty(struct stack* s)
{
	if (s == NULL)
		return 1;
	return 0;
}

// Utility function to push an item to stack
void push(struct stack** s, int x)
{
	struct stack* p = (struct stack*)malloc(sizeof(*p));

	if (p == NULL) {
		fprintf(stderr, "Memory allocation failed.\n");
		return;
	}

	p->data = x;
	p->next = *s;
	*s = p;
}

// Utility function to remove an item from stack
int pop(struct stack** s)
{
	int x;
	struct stack* temp;

	x = (*s)->data;
	temp = *s;
	(*s) = (*s)->next;
	free(temp);

	return x;
}

// Function to find top item
int top(struct stack* s) { return (s->data); }

// Recursive function to insert an item x in sorted way
void sortedInsert(struct stack** s, int x)
{
	// Base case: Either stack is empty or newly inserted
	// item is greater than top (more than all existing)
	if (isEmpty(*s) || x > top(*s)) {
		push(s, x);
		return;
	}

	// If top is greater, remove the top item and recur
	int temp = pop(s);
	sortedInsert(s, x);

	// Put back the top item removed earlier
	push(s, temp);
}

// Function to sort stack
void sortStack(struct stack** s)
{
	// If stack is not empty
	if (!isEmpty(*s)) {
		// Remove the top item
		int x = pop(s);

		// Sort remaining stack
		sortStack(s);

		// Push the top item back in sorted stack
		sortedInsert(s, x);
	}
}

// Utility function to print contents of stack
void printStack(struct stack* s)
{
	while (s) {
		printf("%d ", s->data);
		s = s->next;
	}
	printf("\n");
}

// Driver code
int main(void)
{
	struct stack* top;
	initStack(&top);
	int data;
    char ch;
        /*  Perform  operations  */
        do    
        {
            printf("\nSelect one of the operations::");
            printf("\n1. To insert a new node in the Stack Data Structure.");
            printf("\n2. To display the nodes of the Stack Data Structure.");
printf("\n3. To perform sort on the Stack Data Structure.\n");

            int choice;
            scanf("%d",&choice);            
            switch (choice)
            {
            case 1 : 
                printf("\nEnter the value to be inserted\n");
                scanf("%d",&data);
                push(&top,data);                  
                break;                          
            case 2 : 
				printf("Stack elements:\n");
				printStack(top);
                break; 
            case 3 : 
                printf("\nSort applied sucessfully.\n");
                sortStack(&top);
                break;
            default : 
                printf("Wrong Entry\n");
                break;   
            }

            printf("\nDo you want to continue (Type y or n)\n");
            scanf(" %c",&ch);                        
        } while (ch == 'Y'|| ch == 'y'); 
	return 0;
}

Output

The above C code gives this output.

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform a sort on the Stack Data Structure.
1

Enter the value to be inserted
12

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform a sort on the Stack Data Structure.
1

Enter the value to be inserted
45

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform a sort on the Stack Data Structure.
1

Enter the value to be inserted
9

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform a sort on the Stack Data Structure.
1

Enter the value to be inserted
32

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform a sort on the Stack Data Structure.
1

Enter the value to be inserted
87

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform a sort on the Stack Data Structure.
1

Enter the value to be inserted
20

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform a sort on the Stack Data Structure.
1

Enter the value to be inserted
18

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform a sort on the Stack Data Structure.
1

Enter the value to be inserted
56

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform a sort on the Stack Data Structure.
2
Stack elements:
56 18 20 87 32 9 45 12 

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform a sort on the Stack Data Structure.
3

Sort applied successfully.

Do you want to continue (Type y or n)
y

Select one of the operations::
1. To insert a new node in the Stack Data Structure.
2. To display the nodes of the Stack Data Structure.
3. To perform a sort on the Stack Data Structure.
2
Stack elements:
87 56 45 32 20 18 12 9 

Do you want to continue (Type y or n)
N

In this way, we have written C code to perform the sort operation on the stack data structure. There are three functions written for the stack data structure one is to add a new node in the stack data structure, the second one is to display all the content present in the stack data structure, and third and the last function is to perform the sort operation on the stack data structure.

Next TopicLIFO Approach in data structure

← prev next →