Menu driven stack operations

A stack is a linear data structure that follows the principle of Last In First Out (LIFO). It is a collection of items of the same type. This means the last element inserted inside the stack is removed first.
stack of plates

You can think of the stack data structure as the pile of plates on top of another. Here, you can:

Put a new plate on top
Remove the top plate

Basic Operations on Stack

There are some basic operations that allow us to perform different actions on a stack.

Push: Add an element to the top of a stack
Pop: Remove an element from the top of a stack
IsEmpty: Check if the stack is empty
IsFull: Check if the stack is full
Peek: Get the value of the top element without removing it

And, if you want the plate at the bottom, you must first remove all the plates on top. This is exactly how the stack data structure works.

Algorithm

Working of Stack Data Structure :

The operations work as follows:

A pointer called TOP is used to keep track of the top element in the stack.
When initializing the stack, we set its value to -1 so that we can check if the stack is empty by comparing TOP==-1.
On pushing an element, we increase the value of TOP and place the new element in the position pointed to by TOP.
On popping an element, we return the element pointed to by TOP and reduce its value.
Before pushing, we check if the stack is already full.
Before popping, we check if the stack is already empty.

Program using C

//MENU DRIVEN STACK OPERATIONS
#include<stdio.h>
#include<stdlib.h>
#define max 10
int tos = -1;
void display(int[]);
void push(int[], int);
int pop(int[]);
int main()
    {
        int item, choice, s[max], popped_element;
        while(1)
        {
            printf("\n --- MENU --- \n 1. PUSH \n 2. POP \n 3. DISPLAY \n 4. EXIT \n Enter your choice :- ");
            scanf("%d",&choice);
            switch(choice)
            {
                case 1: printf("Enter the element to be pushed :- ");
                        scanf("%d",&item);
                        push(s, item);
                        break;
                case 2: popped_element = pop(s);
                        if(popped_element != 1)
                        printf("\nThe popped element is %d", popped_element);
                        break;
                case 3: display(s);
                        break;
                case 4: exit(0);
                default : printf("\n\nInvalid choice, try again\n");
            }
        }
    }
    
    void display(int s[])
    {
        int i;
        if(tos == -1)
        printf("\n\nUnderflow - The stack is empty\n");
        else
             printf("The stack is :- \n");
        {
            for( i = 0; i <= tos; i++ )
            printf("%d\t",s[i]);
        }
    }
    
    void push(int s[], int item)
    {
        if(tos == max-1)
            printf("\n\nOverflow - Stack is full\n");
        else
            {
                tos = tos+1;
                s[tos] = item;
            }
    }
    
    int pop(int s[])
    {
        int item;
        if(tos == -1)
        {
            printf("\n\nUnderflow - Stack is empty\n");
            return(-1);
        }
        else
        {
            item = s[tos];
            tos--;
            return(item);
        }
    }