DSA using C – Stack

Overview

Stack is kind of data structure which allows operations on data only at one end. It allows access to the last inserted data only. Stack is also called LIFO (Last In First Out) data structure and Push and Pop operations are related in such a way that only last item pushed (added to stack) can be popped (removed from the stack).

Stack Representation

We”re going to implement Stack using array in this article.

Basic Operations

Following are two primary operations of a stack which are following.

• Push − push an element at the top of the stack.

• Pop − pop an element from the top of the stack.

There is few more operations supported by stack which are following.

• Peek − get the top element of the stack.

• isFull − check if stack is full.

• isEmpty − check if stack is empty.

Push Operation

Whenever an element is pushed into stack, stack stores that element at the top of the storage and increments the top index for later use. If storage is full then an error message is usually shown.

// Operation : Push
// push item on the top of the stack 
void push(int data) {
   if(!isFull()){
      // increment top by 1 and insert data 
      intArray[++top] = data;
   } else {
      printf("Cannot add data. Stack is full.n");
   }      
}

Pop Operation

Whenever an element is to be popped from stack, stack retrives the element from the top of the storage and decrements the top index for later use.

// Operation : Pop
// pop item from the top of the stack 
int pop() {
   //retrieve data and decrement the top by 1
   return intArray[top--];        
}

Example

StackDemo.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>

// size of the stack
int size = 8;       

// stack storage
int intArray[8];     

// top of the stack
int top = -1;            

// Operation : Pop
// pop item from the top of the stack 
int pop() {
   //retrieve data and decrement the top by 1
   return intArray[top--];        
}
// Operation : Peek
// view the data at top of the stack 
int peek() {       
   //retrieve data from the top
   return intArray[top];
}
//Operation : isFull
//return true if stack is full 
bool isFull(){
   return (top == size-1);
}

// Operation : isEmpty
// return true if stack is empty 
bool isEmpty(){
   return (top == -1);
}
// Operation : Push
// push item on the top of the stack 
void push(int data) {
   if(!isFull()){
      // increment top by 1 and insert data 
      intArray[++top] = data;
   } else {
      printf("Cannot add data. Stack is full.n");
   }      
}
main() {
   // push items on to the stack 
   push(3);
   push(5);
   push(9);
   push(1);
   push(12);
   push(15);

   printf("Element at top of the stack: %dn" ,peek());
   printf("Elements: n");

   // print stack data 
   while(!isEmpty()){
      int data = pop();
      printf("%dn",data);
   }
   printf("Stack full: %sn" , isFull()?"true":"false");
   printf("Stack empty: %sn" , isEmpty()?"true":"false");
}

Output

If we compile and run the above program then it would produce following output −

Element at top of the stack: 15
Elements: 
15
12
1
9
5
3
Stack full: false
Stack empty: true