Stack

Stack is a linear data structure in which the insertion and deletion operations are performed at
only one end. In a stack, adding and removing of elements are performed at a single position which is
known as "top". That means, a new element is added at top of the stack and an element is removed
from the top of the stack. In stack, the insertion and deletion operations are performed based
on LIFO (Last In First Out) principle.

In a stack, the insertion operation is performed using a function called "push" and deletion operation
is performed using a function called "pop".

In the figure, PUSH and POP operations are performed at a top position in the stack. That means, both
the insertion and deletion operations are performed at one end (i.e., at Top)

A stack data structure can be defined as follows...

Stack is a linear data structure in which the operations are performed based on LIFO principle.

Stack can also be defined as

"A Collection of similar data items in which both insertion and deletion operations are
performed based on LIFO principle".

Example

If we want to create a stack by inserting 10,45,12,16,35 and 50. Then 10 becomes the bottom-most
element and 50 is the topmost element. The last inserted element 50 is at Top of the stack as shown in
the image below...
 Operations on a Stack

The following operations are performed on the stack...h

1. Push (To insert an element on to the stack)

2. Pop (To delete an element from the stack)

3. Display (To display elements of the stack)

Stack data structure can be implemented in two ways. They are as follows...

1. Using Array

2. Using Linked List

When a stack is implemented using an array, that stack can organize an only limited number of
elements. When a stack is implemented using a linked list, that stack can organize an unlimited
number of elements.

Stack Using Array

A stack data structure can be implemented using a one-dimensional array. But stack implemented
using array stores only a fixed number of data values. This implementation is very simple. Just define
a one dimensional array of specific size and insert or delete the values into that array by using LIFO
principle with the help of a variable called 'top'. Initially, the top is set to -1. Whenever we want to
insert a value into the stack, increment the top value by one and then insert. Whenever we want to
delete a value from the stack, then delete the top value and decrement the top value by one.

Stack Operations using Array

 A stack can be implemented using array as follows...

Before implementing actual operations, first follow the below steps to create an empty stack.

 Step 1 - Include all the header files which are used in the program and define a constant 'SIZE' with
specific value.

 Step 2 - Declare all the functions used in stack implementation.

 Step 3 - Create a one dimensional array with fixed size (int stack[SIZE])

 Step 4 - Define a integer variable 'top' and initialize with '0'. (int top = 0)

 Step 5 - In main method, display menu with list of operations and make suitable function calls to
perform operation selected by the user on the stack.

push(value) - Inserting value into the stack

In a stack, push() is a function used to insert an element into the stack. In a stack, the new element is
always inserted at top position. Push function takes one integer value as parameter and inserts that
value into the stack. We can use the following steps to push an element into the stack...

 Step 1 - Check whether stack is FULL. (top == SIZE)

 Step 2 - If it is FULL, then display "Stack is FULL!!! Insertion is not possible!!!" and terminate
the function.

 Step 3 - If it is NOT FULL, then increment top value by one (top++) and set stack[top] to value
(stack[top] = value).

pop() - Delete a value from the Stack

In a stack, pop() is a function used to delete an element from the stack. In a stack, the element is
always deleted from top position. Pop function does not take any value as parameter. We can use the
following steps to pop an element from the stack...

 Step 1 - Check whether stack is EMPTY. (top == 0)

 Step 2 - If it is EMPTY, then display "Stack is EMPTY!!! Deletion is not possible!!!" and
terminate the function.

 Step 3 - If it is NOT EMPTY, then delete stack[top] and decrement top value by one (top--).

display() - Displays the elements of a Stack

We can use the following steps to display the elements of a stack...

 Step 1 - Check whether stack is EMPTY. (top == 0)

 Step 2 - If it is EMPTY, then display "Stack is EMPTY!!!" and terminate the function.

 Step 3 - If it is NOT EMPTY, then define a variable 'i' and initialize with ‘0’. Display stack[i] value
and increment i value by one (i++).

 Step 3 - Repeat above step until i value becomes 'top'.

Implementation of Stack using Array

#include<stdio.h>
#include<conio.h>
#include<process.h>
int max=5;
int stack[10];
int top=0;
void push();
void pop();
void display();
void main()
{
int ch;
clrscr();
printf("\n performing stack operations ");
for(;;)
{
{
printf("\n1. push 2.pop 3.display 4.exit");
printf("\nenter ur choice");
scanf("%d",&ch);
switch(ch)
{
case 1:push();break;
case 2:pop(); break;
case 3:display(); break;
case 4:exit(0);break;
default: printf("\nenter proper chioce");
}
}
getch();
}
void push()
{
int ele;
if(top==max)
printf("\nstack is overflow ");
 else
{
printf("\nenter the element into stack ");
scanf("%d",&ele);
stack[++top]=ele;
}
}
void pop()
{
if(top==0)
printf("\nstack is undreflow");
else
printf("\npoped element is : %d",stack[top--]);
}
void display()
{
int i;
if(top==0)
printf("\n stack is underflow ");
else
{
printf("\n elements in stack is : \n");
for(i=1;i<=top;i++)
{
printf("%d\t",stack[i]);
}
}
}
 Queue
Queue is a linear data structure in which the insertion and deletion operations are performed at
two different ends. In a queue data structure, adding and removing elements are performed at two
different positions. The insertion is performed at one end and deletion is performed at another end. In
a queue data structure, the insertion operation is performed at a position which is known as 'rear' and
the deletion operation is performed at a position which is known as 'front'. In queue data structure, the
insertion and deletion operations are performed based on FIFO (First In First Out) principle.

In a queue data structure, the insertion operation is performed using a function called "enQueue()"
and deletion operation is performed using a function called "deQueue()".

Queue data structure can be defined as follows...

Queue data structure is a linear data structure in which the operations are performed based on
FIFO principle.
A queue data structure can also be defined as
"Queue data structure is a collection of similar data items in which insertion and deletion
operations are performed based on FIFO principle".
Example
Queue after inserting 25, 30, 51, 60 and 85.

Operations on a Queue
The following operations are performed on a queue data structure...
1. enQueue(value) - (To insert an element into the queue)
2. deQueue() - (To delete an element from the queue)
3. display() - (To display the elements of the queue)
Queue data structure can be implemented in two ways. They are as follows...
1. Using Array
2. Using Linked List
When a queue is implemented using an array, that queue can organize an only limited number of
elements. When a queue is implemented using a linked list, that queue can organize an unlimited
number of elements.
A queue data structure can be implemented using one dimensional array. The queue implemented
using array stores only fixed number of data values. The implementation of queue data structure using
array is very simple. Just define a one dimensional array of specific size and insert or delete the values
into that array by using FIFO (First In First Out) principle with the help of variables 'front' and
'rear'. Initially both 'front' and 'rear' are set to -1. Whenever, we want to insert a new value into the
queue, increment 'rear' value by one and then insert at that position. Whenever we want to delete a
value from the queue, then delete the element which is at 'front' position and increment 'front' value by
one.
Queue Operations using Array
Queue data structure using array can be implemented as follows...

Before we implement actual operations, first follow the below steps to create an empty queue.
 Step 1 - Include all the header files which are used in the program and define a
constant 'SIZE' with specific value.
 Step 2 - Declare all the user defined functions which are used in queue implementation.
 Step 3 - Create a one dimensional array with above defined SIZE (int queue[SIZE])
 Step 4 - Define two integer variables 'front' and 'rear' and initialize both with '-1'. (int front =
-1, rear = -1)
 Step 5 - Then implement main method by displaying menu of operations list and make suitable
function calls to perform operation selected by the user on queue.

enQueue(value) - Inserting value into the queue

In a queue data structure, enQueue() is a function used to insert a new element into the queue. In a
queue, the new element is always inserted at rear position. The enQueue() function takes one integer
value as a parameter and inserts that value into the queue. We can use the following steps to insert an
element into the queue...
 Step 1 - Check whether queue is FULL. (rear == SIZE-1)
 Step 2 - If it is FULL, then display "Queue is FULL!!! Insertion is not possible!!!" and
terminate the function.
 Step 3 - If it is NOT FULL, then increment rear value by one (rear++) and
set queue[rear] = value.

deQueue() - Deleting a value from the Queue

In a queue data structure, deQueue() is a function used to delete an element from the queue. In a
queue, the element is always deleted from front position. The deQueue() function does not take any
value as parameter. We can use the following steps to delete an element from the queue...
 Step 1 - Check whether queue is EMPTY. (front == rear)
 Step 2 - If it is EMPTY, then display "Queue is EMPTY!!! Deletion is not possible!!!" and
terminate the function.
 Step 3 - If it is NOT EMPTY, then increment the front value by one (front ++). Then
display queue[front] as deleted element. Then check whether both front and rear are equal
(front == rear), if it TRUE, then set both front and rear to '-1' (front = rear = -1).

display() - Displays the elements of a Queue

We can use the following steps to display the elements of a queue...
 Step 1 - Check whether queue is EMPTY. (front == rear)
  Step 2 - If it is EMPTY, then display "Queue is EMPTY!!!" and terminate the function.
 Step 3 - If it is NOT EMPTY, then define an integer variable 'i' and set 'i = front+1'.
 Step 4 - Display 'queue[i]' value and increment 'i' value by one (i++). Repeat the same until 'i'
value reaches to rear (i <= rear)

Implementation of Queue Datastructure using Array

#include<stdio.h>
#include<conio.h>
#define SIZE 10

void enQueue(int);
void deQueue();
void display();
int queue[SIZE], front = -1, rear = -1;
void main()
{
int value, choice;
clrscr();
while(1){
printf("\n\n***** MENU *****\n");
printf("1. Insertion\n2. Deletion\n3. Display\n4. Exit");
printf("\nEnter your choice: ");
scanf("%d",&choice);
switch(choice){
case 1: printf("Enter the value to be insert: ");
scanf("%d",&value);
enQueue(value);
break;
case 2: deQueue();
break;
case 3: display();
break;
case 4: exit(0);
default: printf("\nWrong selection!!! Try again!!!");
}
}
}
void enQueue(int value){
if(rear == SIZE-1)
printf("\nQueue is Full!!! Insertion is not possible!!!");
else{
if(front == -1)
front = 0;
rear++;
queue[rear] = value;
printf("\nInsertion success!!!");
 }
}
void deQueue(){
if(front == rear)
printf("\nQueue is Empty!!! Deletion is not possible!!!");
else{
printf("\nDeleted : %d", queue[front]);
front++;
if(front == rear)
front = rear = -1;
}
}
void display(){
if(rear == -1)
printf("\nQueue is Empty!!!");9
else{
int i;
printf("\nQueue elements are:\n");
for(i=front; i<=rear; i++)
printf("%d\t",queue[i]);
}
}

Output:

***** MENU *****

1. Insertion
2. Deletion
3. Display
4. Exit
Enter your choice: 1
Enter the value to be insert: 12

Insertion success!!!

***** MENU *****

1. Insertion
2. Deletion
3. Display
4. Exit
Enter your choice: 1
Enter the value to be insert: 23

Insertion success!!!

***** MENU *****

1. Insertion
2. Deletion
3. Display
4. Exit
Enter your choice: 1
Enter the value to be insert: 34

Insertion success!!!

***** MENU *****

1. Insertion
2. Deletion
3. Display
4. Exit
Enter your choice: 1
Enter the value to be insert: 45

Insertion success!!!

***** MENU *****

1. Insertion
2. Deletion
3. Display
4. Exit
Enter your choice: 1
Enter the value to be insert: 56

Insertion success!!!

***** MENU *****

1. Insertion
2. Deletion
3. Display
4. Exit
Enter your choice: 1
Enter the value to be insert: 67

Queue is Full!!! Insertion is not possible!!!