Stack in C

A stack is a linear data structure that follows the Last In, First Out (LIFO) principle, meaning the last element added is the first one to be removed.

• The stack can be represented as a structure containing a fixed-size array and a top pointer, which is initialized to -1 to indicate an empty stack.
• Using an array-based stack is memory-efficient but has a fixed size, whereas a linked-list-based stack allows dynamic memory allocation and can grow or shrink at runtime.
• The maximum size of an array-based stack can be defined according to requirements.

Basic Operations in C

Following are some basic operations in the stack that make it easy to manipulate the stack data structure:

As we can see, the stack offers O(1) time complexity for all the operation but with a catch that we can only perform these operation to the topmost element. So, we need to consider our requirements to take advantage of stack data structure.

Let's see how to implement these basic operations for our stack in C.

// C Program to demonstrate how to Implement a Stack
#include <stdio.h>
#include <stdbool.h>

// Define the maximim capacity of the stack
#define MAX_SIZE 100

// Define a structure for the stack
typedef struct {
    int arr[MAX_SIZE];  
    int top;        
} Stack;

// Function to initialize the stack
void initialize(Stack *stack) {
    stack->top = -1;  
}

// Function to check if the stack is empty
bool isEmpty(Stack *stack) {
    return stack->top == -1;  
}

// Function to check if the stack is full
bool isFull(Stack *stack) {
    return stack->top == MAX_SIZE - 1;  
}

// Function to push an element onto the stack
void push(Stack *stack, int value) {
    if (isFull(stack)) {
        printf("Stack Overflow\n");
        return;
    }
    stack->arr[++stack->top] = value;
    printf("Pushed %d onto the stack\n", value);
}

// Function to pop an element from the stack
int pop(Stack *stack) {
    if (isEmpty(stack)) {
        printf("Stack Underflow\n");
        return -1;
    }

    int popped = stack->arr[stack->top];
    stack->top--;
    printf("Popped %d from the stack\n", popped);
    return popped;
}

// Function to peek the top element of the stack
int peek(Stack *stack) {
    if (isEmpty(stack)) {
        printf("Stack is empty\n");
        return -1;
    }
    return stack->arr[stack->top];
}

int main() {
    Stack stack;
    initialize(&stack);  

    push(&stack, 3);
    printf("Top element: %d\n", peek(&stack));

    push(&stack, 5);
    printf("Top element: %d\n", peek(&stack));

    push(&stack, 2);
    printf("Top element: %d\n", peek(&stack));

    push(&stack, 8);
    printf("Top element: %d\n", peek(&stack));

    while (!isEmpty(&stack)) {
        printf("Top element: %d\n", peek(&stack));
        printf("Popped element: %d\n", pop(&stack));
    }

    return 0;
}

Pushed 3 onto the stack
Top element: 3
Pushed 5 onto the stack
Top element: 5
Pushed 2 onto the stack
Top element: 2
Pushed 8 onto the stack
Top element: 8
Top element: 8
Popped 8 from the stack
Poppe...

1. isFull Function

The isFull() function provides the information about whether the stack have some space left or it is completely full. We know that the max capacity of the stack is MAX_SIZE elements. So, the max value of top can be MAX_SIZE - 1.

Algorithm of Stack isFull:

• If top >= MAX_SIZE - 1, return true.
• Else return false.

2. isEmpty Function

The isEmpty function will check whether the stack is empty or not. We know that when the stack is empty, the top is equal to -1.

Algorithm of Stack isEmpty:

• If the top pointer==-1 return true
• Else return false.

3. Push Function

The push function will add (or push) an element to the stack. The edge case here will be when we try to add a new element when the stack is already full. It is called stack overflow and we have to check for it before inserted new element.

Algorithm of Stack Push:

• Check whether if the stack is full.
• If stack is full then display the overflow message.
• If stack is not full then increment the top pointer.
• Add the new element to position pointed to by the top pointer.

4. Pop Function

The pop function will remove an element from the stack. One case that can occur here is when we try to remove the top using pop() function when the stack is already empty. Such condition is called stack underflow and can be easily checked.

Algorithm of Stack Pop:

• Check whether if stack is empty.
• If stack is empty then display the underflow message.
• If stack is not empty then remove the element at top position
• Decrement the top pointer of the stack.

5. top Function

The peek function will return the topmost element of the stack in constant time. If the stack is empty it returns -1.

Algorithm for Stack Top Function

• Check whether the stack is empty.
• If it is empty, return -1.
• Else return, stack.data[top] element.

Related Articles:

• Stack Data Structure
• Stack using Linked List