Data Structure(22317)

Computer Engg.

Unit -3
Stacks and Queues
Prepared By
Mrs. Kavita G Kurale
 What is a 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.
• 10 20 30 40 50 fifo
• [0] [1] [ 2] [ 3] [5]
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)

In a stack,
1. the insertion operation is performed using a function called "push“
2. deletion operation is performed using a function called "pop".
• 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".
 Stack 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...

1) Initialize () – Make/create Stack empty

2) Empty() – To determine if stack is empty or not
3) Full() – To determine if a stack is full or not
4) Push - To insert an element on top of the stack
5) Pop - To delete an element from top of the stack
6) Display - To display elements of the stack
 Stack data structure can be implemented in two ways.
1. Using Array
2. Using Linked List

• 1. 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...

• 1. Initialze the 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 '-1'. (int top = -1)

• 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.
• Stack Operations using Array

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

• 1. To check empty the 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 – Check top of stack is empty. (top == -1)

• Step 4 – Return stack is empty message

• Stack Operations using Array

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

• 1. To check stack is Full.

• 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 – Check stack is Full. (top == Max-1)

• Step 4 – Return stack is Full message

• 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 on to the stack...

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

• 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 == -1)

• 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 == -1)

• 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 top. Display stack[i] value and decrement i value by one (i--).

• Step 3 - Repeat above step until i value becomes '0'.

#include<stdio.h>
#include<conio.h>
#define SIZE 10
void push(int);
void pop();
void display();

int stack[SIZE], top = -1;

void main()
{
int value, choice;
clrscr();
while(1){
printf("\n\n***** MENU *****\n");
printf("1. Push\n2. Pop\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);
push(value);
break;
case 2: pop();
break;
case 3: display();
break;
case 4: exit(0);
default: printf("\nWrong selection!!! Try again!!!");
• void push(int value){
• if(top == SIZE-1)
• printf("\nStack is Full!!! Insertion is not possible!!!");
• else{
• top++;
• stack[top] = value;
• printf("\nInsertion success!!!");
• }
• }
• void pop(){
• if(top == -1)
• printf("\nStack is Empty!!! Deletion is not possible!!!");
• else{
• printf("\nDeleted : %d", stack[top]);
• top--;
• }
• }
• void display(){
• if(top == -1)
• printf("\nStack is Empty!!!");
• else{
• int i;
• printf("\nStack elements are:\n");
• for(i=top; i>=0; i--)
• printf("%d\n",stack[i]);
• }
• }
Applications of Stack