DATA STRUCTURES

UNIT-II
STACKS:

Contents Regarding Stack Are:

Introduction And Definition
Representation
Operations On Stack
Implementation Of Stack Using Array
Implementation Of Stack Using Linked list
Applications.

Introduction and Definition:

A stack can be implemented by using one dimensional array.

Stack implemented using can store fixed number of data values, it is easy to implement and initially
top as an integer is set to 0(zero).
Stack can be implemented using lifo principle which means last in first out.
In other words the first inserted value will be deleted at last.
For insertion we need to increment top value and for deletion we need to decremenr the top value.

FEATURES:

1. Stack is an ordered list of similar data type.

2. Stack is a LIFO structure. (Last in First out).

3. push() function is used to insert new elements into the Stack and pop() is used to delete an element from
the stack. Both insertion and deletion are allowed at only one end of Stack called Top.

4. Stack is said to be in Overflow state when it is completely full and is said to be in Underflow state if it is
completely empty.

REPRESENTATION:

Insertion and deletion can be done only one side in the concept of stack with the help of variable called top.

(LEVEL OR POSITION INDICATOR)TOP

(PUSH())------INSERTION (POP ())------DELETION

Bit Institute Of Technology, hindupur Page 1

 DATA STRUCTURES

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 '-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.

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)

Bit Institute Of Technology, hindupur Page 2

 DATA STRUCTURES

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'.

STACKS USING ARRAYS:IN

#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);

Bit Institute Of Technology, hindupur Page 3

 DATA STRUCTURES
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]);
}
}
OUTPUT:

RRAY
S
S: STACKS USING LINKED LIST:

Bit Institute Of Technology, hindupur Page 4

 DATA STRUCTURES

The major problem with the stack implemented using array is, it works only for fixed number of data
values.
That means the amount of data must be specified at the beginning of the implementation itself.
Stack implemented using array is not suitable, when we don't know the size of data which we are going to
use.
A stack data structure can be implemented by using linked list data structure. The stack implemented using
linked list can work for unlimited number of values.
That means stack implemented using linked list works for variable size of data.
So, there is no need to fix the size at the beginning of the implementation.
The Stack implemented using linked list can organize as many data values as we want.
In linked list implementation of a stack, every new element is inserted as 'top' element.
That means every newly inserted element is pointed by 'top'.
Whenever we want to remove an element from the stack, simply remove the node which is pointed by 'top'
by moving 'top' to its next node in the list.
The next field of the first element must be always NULL.

Example

In above example, the last inserted node is 99 and the first inserted node is 25. The order of elements inserted is 25,
32,50 and 99.

Operations

To implement stack using linked list, we need to set the following things before implementing actual operations.

Step 1: Include all the header files which are used in the program. And declare all the user defined

functions.

Step 2: Define a 'Node' structure with two members data and next.

Step 3: Define a Node pointer 'top' and set it to NULL.

Bit Institute Of Technology, hindupur Page 5

 DATA STRUCTURES

Step 4: Implement the main method by displaying Menu with list of operations and make suitable function

calls in the main method.

push(value) - Inserting an element into the Stack

We can use the following steps to insert a new node into the stack...

Step 1: Create a newNode with given value.

Step 2: Check whether stack is Empty (top == NULL)

Step 3: If it is Empty, then set newNode next = NULL.

Step 4: If it is Not Empty, then set newNode next = top.

Step 5: Finally, set top = newNode.

pop() - Deleting an Element from a Stack

We can use the following steps to delete a node from the stack...

Step 1: Check whether stack is Empty (top == NULL).

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 define a Node pointer 'temp' and set it to 'top'.

Step 4: Then set 'top = top next'.

Step 7: Finally, delete 'temp' (free(temp)).

display() - Displaying stack of elements

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

Step 1: Check whether stack is Empty (top == NULL).

Step 2: If it is Empty, then display 'Stack is Empty!!!' and terminate the function.

Bit Institute Of Technology, hindupur Page 6

 DATA STRUCTURES

Step 3: If it is Not Empty, then define a Node pointer 'temp' and initialize with top.

Step 4: Display 'temp data --->' and move it to the next node. Repeat the same until temp reaches to

the first node in the stack (temp next != NULL).

Step 4: Finally! Display 'temp data ---> NULL'.

#include<stdio.h>
#include<conio.h>

struct Node
{
int data;
struct Node *next;
}*top = NULL;

void push(int);
void pop();
void display();

void main()
{
int choice, value;
clrscr();
printf("\n:: Stack using Linked List ::\n");
while(1){
printf("\n****** MENU ******\n");
printf("1. Push\n2. Pop\n3. Display\n4. Exit\n");
printf("Enter 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!!! Please try again!!!\n");
}
}
}
void push(int value)
{
struct Node *newNode;
newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;
if(top == NULL)
newNode->next = NULL;
else
newNode->next = top;
top = newNode;
printf("\nInsertion is Success!!!\n");
}
void pop()
{

Bit Institute Of Technology, hindupur Page 7

 DATA STRUCTURES
if(top == NULL)
printf("\nStack is Empty!!!\n");
else{
struct Node *temp = top;
printf("\nDeleted element: %d", temp->data);
top = temp->next;
free(temp);
}
}
void display()
{
if(top == NULL)
printf("\nStack is Empty!!!\n");
else{
struct Node *temp = top;
while(temp->next != NULL){
printf("%d--->",temp->data);
temp = temp -> next;
}
printf("%d--->NULL",temp->data);
}
}

Output:

Bit Institute Of Technology, hindupur Page 8

 DATA STRUCTURES

Applications:

1. Expression Evolution

2. Expression conversion

1. Infix to Postfix

Bit Institute Of Technology, hindupur Page 9

 DATA STRUCTURES
2. Infix to Prefix

3. Postfix to Infix

4. Prefix to Infix

3. Parsing

4. Simulation of recursion

5. Evaluation of arithmetic expression

6. Implementation of back button in computer

The way to write arithmetic expression is known as notation. An arithmetic expression can be written in 3 different
equivalent notations. They are

Infix notation
Prefix notation
Postfix notation

Infix notation:

When the operator can be in between operands such expression can be known as Infix notation

prefix notation:

When the operator can be placed ahead of operands such expression can be known as prefix notation.

postfix notation:

When the operator can be placed after operands such expression can be known as postfix notation

s.no Infix notation prefix notation postfix notation

1 a+b +ab ab+

2 (a+b)*c *+abc ab+c*
3 a*(b+c) *a+bc Abc+*
4 a/b/*c/d +/ab/cd Ab/cd/+

5 (a+b)*(c+d) *+ab+cd Ab+cd+*

6 ((a+b)*c)-d -*+abcd Ab+c*d-

The final Postfix Expression is as follows..

Postfix evaluation algorithm:

Bit Institute Of Technology, hindupur Page 10

 DATA STRUCTURES

1. Scan expression from left to right

2. If it is operand push it to stack

3. If it is an operator pull operand from stack and perform operation

4. Store the output of step 3, back to stack

5. Scan the expression until all operands are consumed

6. Pop the stack and perform operation

Bit Institute Of Technology, hindupur Page 11

 DATA STRUCTURES

Bit Institute Of Technology, hindupur Page 12

 DATA STRUCTURES

Recursion:

Recursion is a programming technique that allows the programmer to express operations in terms of
themselves. In C, this takes the form of a function that calls itself.
A useful way to think of recursive functions is to imagine them as a process being performed where one of
the instructions is to "repeat the process".
Recursion classifiedinto 2 types
o Direct recursion
o Indirect recursion

Direct recursion:

The process calling the same function directly to solve a problem such recursion can be known as Direct recursion

In-Direct recursion:

The process calling the same function indirectly with the help of another function to solve a problem such recursion
can be known as in-direct recursion

int main()
{
... .. ...
recurse();
... .. ...
}
void recurse()
{
... .. ...
call();
... .. ...
}
Void call()
{
... .. ...
recurse(); }

Bit Institute Of Technology, hindupur Page 13

 DATA STRUCTURES

Example: Sum of Natural Numbers Using Recursion:

#include <stdio.h>
int sum(int n);

int main()
{
int number, result;

printf("Enter a positive integer: ");

scanf("%d", &number);

result = sum(number);

printf("sum=%d", result);
}

int sum(int num)

{
if (num!=0)
return num + sum(num-1); // sum() function calls itself
else
return num;
}

Factorial using recursion:

#include <stdio.h>

int factorial(unsigned int i) {

if(i <= 1) {
return 1;
}
return i * factorial(i - 1);
}

int main() {
int i = 15;
printf("Factorial of %d is %d\n", i, factorial(i));
return 0;
}

Bit Institute Of Technology, hindupur Page 14

 DATA STRUCTURES

Queue:hat is a 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 of elements are performed at two different positions. The
insertion is performed at one end and deletion is performed at other 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 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.

Bit Institute Of Technology, hindupur Page 15

 DATA STRUCTURES

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 array, that queue can organize only limited number of elements. When a queue
is implemented using linked list, that queue can organize unlimited number of elements.

Queue Using Array:

A queue data structure can be implemented using one dimensional array. But, queue implemented using
array can store 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 increment 'front' value by one and then display
the value at 'front' position as deleted element.

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

Bit Institute Of Technology, hindupur Page 16

 DATA STRUCTURES

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 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 3: Display 'queue[i]' value and increment 'i' value by one (i++). Repeat the same until 'i' value is equal

to rear (i <= rear)

Bit Institute Of Technology, hindupur Page 17

 DATA STRUCTURES
#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!!!");
else{
int i;
printf("\nQueue elements are:\n");
for(i=front; i<=rear; i++)
printf("%d\t",queue[i]);
}

Bit Institute Of Technology, hindupur Page 18

 DATA STRUCTURES
}

Output:

Queue using Linked List:

The major problem with the queue implemented using array is, It will work for only fixed number of data.
That means, the amount of data must be specified in the beginning itself.
Queue using array is not suitable when we don't know the size of data which we are going to use. A queue
data structure can be implemented using linked list data structure.
The queue which is implemented using linked list can work for unlimited number of values.
That means, queue using linked list can work for variable size of data (No need to fix the size at beginning
of the implementation).
The Queue implemented using linked list can organize as many data values as we want.

In linked list implementation of a queue, the last inserted node is always pointed by 'rear' and the first node
is always pointed by 'front'.

Queue
From the taxonomy this structure is Linear - Sequential Access - First-in-First-out

Features:

1. A list structure with two access points called the front and rear.

2. All insertions (enqueue) occur at the rear and deletions (dequeue) occur at the front.

3. Varying length (dynamic).

4. Homogeneous components

5. Has a First-In, First-Out characteristic (FIFO)

Example

Bit Institute Of Technology, hindupur Page 19

 DATA STRUCTURES

In above example, the last inserted node is 50 and it is pointed by 'rear' and the first inserted node is 10 and it is
pointed by 'front'. The order of elements inserted is 10, 15, 22 and 50.erations

To implement queue using linked list, we need to set the following things before implementing actual
operations:

Step 1: Include all the header files which are used in the program. And declare all the user defined

functions.

Step 2: Define a 'Node' structure with two members data and next.

Step 3: Define two Node pointers 'front' and 'rear' and set both to NULL.

Step 4: Implement the main method by displaying Menu of list of operations and make suitable function

calls in the main method to perform user selected operation.

enQueue(value) - Inserting an element into the Queue

We can use the following steps to insert a new node into the queue...

Step 1: Create a newNode with given value and set 'newNode next' to NULL.

Step 2: Check whether queue is Empty (rear == NULL)

Step 3: If it is Empty then, set front = newNode and rear = newNode.

Step 4: If it is Not Empty then, set rear next = newNode and rear = newNode.

deQueue() - Deleting an Element from Queue

We can use the following steps to delete a node from the queue...

Step 1: Check whether queue is Empty (front == NULL).

Bit Institute Of Technology, hindupur Page 20

 DATA STRUCTURES

Step 2: If it is Empty, then display "Queue is Empty!!! Deletion is not possible!!!" and terminate from

the function

Step 3: If it is Not Empty then, define a Node pointer 'temp' and set it to 'front'.

Step 4: Then set 'front = front next' and delete 'temp' (free(temp)).

display() - Displaying the elements of Queue

We can use the following steps to display the elements (nodes) of a queue...

Step 1: Check whether queue is Empty (front == NULL).

Step 2: If it is Empty then, display 'Queue is Empty!!!' and terminate the function.

Step 3: If it is Not Empty then, define a Node pointer 'temp' and initialize with front.

Step 4: Display 'temp data --->' and move it to the next node. Repeat the same until 'temp' reaches to

'rear' (temp next != NULL).

Step 4: Finally! Display 'temp data ---> NULL'.

#include<stdio.h>
#include<conio.h>

struct Node
{
int data;
struct Node *next;
}*front = NULL,*rear = NULL;

void insert(int);
void delete();
void display();

void main()
{
int choice, value;
clrscr();
printf("\n:: Queue Implementation using Linked List ::\n");
while(1){
printf("\n****** MENU ******\n");
printf("1. Insert\n2. Delete\n3. Display\n4. Exit\n");
printf("Enter your choice: ");
scanf("%d",&choice);
switch(choice){
case 1: printf("Enter the value to be insert: ");
scanf("%d", &value);
insert(value);

Bit Institute Of Technology, hindupur Page 21

 DATA STRUCTURES
break;
case 2: delete(); break;
case 3: display(); break;
case 4: exit(0);
default: printf("\nWrong selection!!! Please try again!!!\n");
}
}
}
void insert(int value)
{
struct Node *newNode;
newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = value;
newNode -> next = NULL;
if(front == NULL)
front = rear = newNode;
else{
rear -> next = newNode;
rear = newNode;
}
printf("\nInsertion is Success!!!\n");
}
void delete()
{
if(front == NULL)
printf("\nQueue is Empty!!!\n");
else{
struct Node *temp = front;
front = front -> next;
printf("\nDeleted element: %d\n", temp->data);
free(temp);
}
}
void display()
{
if(front == NULL)
printf("\nQueue is Empty!!!\n");
else{
struct Node *temp = front;
while(temp->next != NULL){
printf("%d--->",temp->data);
temp = temp -> next;
}
printf("%d--->NULL\n",temp->data);
}
}

Bit Institute Of Technology, hindupur Page 22

 DATA STRUCTURES

Applications of queue:

1. Serving requests on a single shared resource, like a printer, CPU task scheduling etc.

2. In real life, Call Center phone systems will use Queues, to hold people calling them in an order, until a
service representative is free.

Bit Institute Of Technology, hindupur Page 23

 DATA STRUCTURES
3. Handling of interrupts in real-time systems. The interrupts are handled in the same order as they arrive,
First come first served.

4. Traffic control systems.

Note:

Similarly different types of queues are there such as

7. Double ended queue(insertion, deletion both sides)

8. Circular queue.

Bit Institute Of Technology, hindupur Page 24