FaaDoOEngine

ers.com
Engaging Peers, Inspiring Careers!

Indias No.1 website for:

IIT-JEE/AIEEE preparation resources

Coaching centre packages
Engineering Major and Minor projects
Seminar reports
Paper presentations
EBOOKS
Resumes/CVs, and so much more

Data Structures
-- Data processing often involves in processing huge volumes of data. Many Companies handle million
records of data stored in database. Many ways are formulated to handle data efficiently.
-- An User-defined data type is a combination of different primary data types, which represents a
complex entity.
-- An Abstract Data Type ( A D T ) not only represents a set of complex data objects, but also includes a
set of operations to be performed on these objects, defines that how the data objects are organized.
-- The group of methods implements a set rules, which defines a logical way of handling data.
-- The complex entity along with its group of methods is called Abstract Data Type ( A D T ) .
-- Data structure is described as an instance of Abstract Data Type ( ADT ).
-- We can define that Data structure is a kind of representation of logical relationship between related
data elements. In data structure, decision on the operations such as storage, retrieval and access must be
carried out between the logically related data elements.

Data Structure
Linear
Linear Lists

Stacks

Non-Linear
Queues

Trees

Some Common Operations on Data structures

Insertion : adding a new element to the collection.
Deletion : removing an element from a collection.
Traversal : access and examine each element in collection.
Search : find whether an element is present or not.
Sorting : rearranging elements in a particular order.
Merging : combining two collections into one collection.

Graphs

Some Data structures

Arrays
Strings
Lists
Stacks
Queues
Trees
Graphs
Dictionaries
Maps
Hash Tables
Sets
Lattice
Neural-Nets

Arrays Linked Lists

1)
2)
3)

4)

5)

Limitations of Arrays
Fixed in size :
Once an array is created, the size of array
cannot be increased or decreased.
Wastage of space :
If no. of elements are less, leads to wastage of
space.
Sequential Storage :
Array elements are stored in contiguous
memory locations. At the times it might so
happen that enough contiguous locations might
not be available. Even though the total space
requirement of an array can be met through a
combination of non-contiguous blocks of
memory, we would still not be allowed to create
the array.
Possibility of overflow :
If program ever needs to process more than
the size of array, there is a possibility of
overflow and code breaks.
Difficulty in insertion and deletion :
In case of insertion of a new element, each
element after the specified location has to be
shifted one position to the right. In case of
deletion of an element, each element after the
specified location has to be shifted one position
to the left.

What is a Linked List

The elements of a linked list are not constrained to
be stored in adjacent locations. The individual
elements are stored somewhere in memory, rather
like a family dispersed, but still bound together. The
order of the elements is maintained by explicit links
between them.

The Linked List is a collection of elements called

nodes, each node of which stores two items of
information, i.e., data part and link field.
-- The data part of each node consists the data
record of an entity.
-- The link field is a pointer and contains the
address of next node.
-- The beginning of the linked list is stored in a
pointer termed as head which points to the first
node.
-- The head pointer will be passed as a parameter
to any method, to perform an operation.
-- First node contains a pointer to second node,
second node contains a pointer to the third node and
so on.
-- The last node in the list has its next field set to
NULL to mark the end of the list.

struct node {
int rollno; struct node *next;
};
int main() {
struct node *head,*n1,*n2,*n3,*n4;
/* creating a new node */
n1=(struct node *) malloc(sizeof(struct node));
n1->rollno=101;
n1->next = NULL;
/* referencing the first node to head pointer
*/
head = n1;
/* creating a new node */
n2=(struct node *)malloc(sizeof(struct node));
n2->rollno=102;
n2->next = NULL;
/* linking the second node after first node */
n1->next = n2;
/* creating a new node * /
n3=(struct node *)malloc(sizeof(struct node));
n3->rollno=104;
n3->next=NULL;
/* linking the third node after second node */
n2->next = n3;
/* creating a new node */
n4=(struct node *)malloc (sizeof (struct node));
n4->rollno=103;
n4->next=NULL;
/* inserting the new node between
second node and third node */
n2->next = n4;

Creating a Singly Linked List

/* deleting n2 node */
n1->next = n4;
free(n2);
}
150

101

NULL

head

150

n1-node

720

102

101

150

720
n2-node

150
n1-node

150

101

720

102

101

400

head

150
n1-node

102

910

720
n2-node

150
n1-node

150

NULL

104 NULL
910
n3-node

720

400
n2-node

104 NULL
103

910

910
n3-node

720
n4-node

150

101

head

150

103

720

n1-node

102

720

400
n2-node

910
720
n4-node

104 NULL
910
n3-node

Implementing Singly Linked List

struct node {
int data;
struct node *next;
};
struct node *createnode() {
struct node *new;
new = (struct node *)malloc(sizeof(struct node));
printf("\nEnter the data : ");
scanf("%d",&new->data);
new->next = NULL;
return new;
}
void append(struct node **h) {
struct node *new,*temp;
new = createnode();
if(*h == NULL) {
*h = new;
return;
}
temp = *h;
while(temp->next!=NULL) temp = temp->next;
temp->next = new;
}
void display(struct node *p) {
printf("\nContents of the List : \n\n");
while(p!=NULL) {
printf("\t%d",p->data);
p = p->next;

}
}
void insert_after(struct node **h) {
struct node *new,*temp; int k;
if(*h == NULL) return;
printf("\nEnter data of node after which node : ");
scanf("%d",&k);
temp = *h;
while(temp!=NULL && temp->data!=k)
temp = temp->next;
if(temp!=NULL) {
new=createnode();
new->next = temp->next;
temp->next = new;
}
}
void insert_before(struct node **h) {
struct node *new,*temp,*prev ;
int k;
if(*h==NULL) return;
printf("\nEnter data of node before which node :
");
scanf("%d",&k);
if((*h)->data == k) {
new = createnode();
new->next = *h;
*h = new; return;
}
temp = (*h)->next; prev = *h;

Implementing Singly Linked List ( continued )

while(temp!=NULL && temp->data!=k) {
prev=temp;
temp=temp->next;
}
if(temp!=NULL) {
new = createnode();
new->next = temp;
prev->next = new;
}
}
void delnode(struct node **h) {
struct node *temp,*prev;
int k;
if(*h==NULL) return;
printf("\nEnter the data of node to be removed : ");
scanf("%d",&k);
if((*h)->data==k) {
temp=*h;
*h=(*h)->next;
free(temp);
return;
}
temp=(*h)->next;
prev=*h;
while(temp!=NULL && temp->data!=k) {
prev=temp;
temp=temp->next;
}

if(temp!=NULL) {
prev->next = temp->next;
free(temp);
}
}
void search(struct node *h) {
struct node *temp;
int k;
if(h==NULL)return;
printf("\nEnter the data to be searched : ");
scanf("%d",&k);
temp=h;
while(temp!=NULL && temp->data!=k)
temp=temp->next;
(temp==NULL)?
printf("\n\t=>Node does not exist") :
printf("\n\t=>Node exists");
}
void destroy(struct node **h) {
struct node *p;
if(*h==NULL) return;
while(*h!=NULL) {
p = (*h)->next;
free(*h);
*h=p;
}
printf("\n\n ******Linked List is destroyed******");
}

Implementing Singly Linked List ( continued )

int main() {
struct node *head=NULL;
int ch;
while(1) {
printf("\n1.Append");
printf("\n2.Display All");
printf("\n3.Insert after a specified node");
printf("\n4.Insert before a specified node");
printf("\n5.Delete a node");
printf("\n6.Search for a node");
printf("\n7.Distroy the list");
printf("\n8.Exit program");
printf("\n\n\tEnter your choice : ");
scanf("%d",&ch);
switch(ch) {
case 1:append(&head);break;
case 2:display(head);break;
case 3:insert_after(&head);break;
case 4:insert_before(&head);break;
case 5:delnode(&head);break;
case 6:search(head);break;
case 7:destroy(&head);break;
case 8:exit(0);break;
default :
printf( "Wrong Choice, Enter correct one : ");
}
}
}

/* function to sort linked list */

void sort(struct node *h) {
struct node *p,*temp;
int i, j, n, t, sorted=0;
temp=h;
for(n=0 ; temp!=NULL ; temp=temp->next) n++;
for(i=0;i<n-1&&!sorted;i++) {
p=h; sorted=1;
for(j=0;j<n-(i+1);j++) {
if ( p->data > ( p->next )->data ) {
t=p->data;
p->data =(p->next)->data;
(p->next)->data = t;
sorted=0;
}
p=p->next;
}
}
}
/* function to count number of node in the list */
int count ( struct node *h)
{
int i;
for( i=0 ; h!=NULL ; h=h->next)
i++;
return i;
}

Algorithm for adding two polynomials in linked lists

Add_Polynomial( list p, list q )
set p, q to point to the two first nodes (no headers)
initialize a linked list r for a zero polynomial
while p != null and q != null
if p.exp > q.exp
create a node storing p.coeff and p.exp
insert at the end of list r
advance p
else if q.exp > p.exp
create a node storing q.coeff and q.exp
insert at the end of list r
advance q
else if p.exp == q.exp
if p.coeff + q.coeff != 0
create a node storing p.coeff + q.coeff and p.exp
insert at the end of list r
advance p, q
end while
if p != null
copy the remaining terms of p to end of r
else if q != null
copy the remaining terms of q to end of r

Doubly Linked List

Pitfalls encountered while using singly linked list :
1) A singly linked list allows traversal of the list in forward direction, but not in backward direction.
2) Deleting a node from a list requires keeping track of the previous node,.
3) In the list any node gets corrupted, the remaining nodes of the list become unusable.
These problems of singly linked lists can be overcome by doubly linked list.
A Doubly Linked List is a data structure having an ordered list of nodes, in which each node
consists of two pointers. One pointer is to store the address of next node like in singly linked list. The
second pointer stores the address of previous node. It is also known as two-way list.
The specialty of DLL is that the list can be traversed in forward as well as backward directions.
The concept of DLL is also used to representing tree data structures.

head

tail

A
/* a node in doubly linked list */
struct node
{
struct node *prev;
int data ;
struct node *next;
}

C
B

D
C

Tree structure using Doubly Linked List

Insertion of node in Doubly Linked List

B
p

q
B

Deletion of node in Doubly Linked List

p
D

Implementing Doubly Linked List

struct node {
struct node *prev;
int data;
struct node *next;
};
struct node *createnode() {
struct node *new;
new = (struct node *)malloc(sizeof(struct node));
printf("\nEnter the data : ");
scanf("%d",&new->data);
new->prev = NULL;
new->next = NULL;
return new;
}
void append(struct node **h) {
struct node *new,*temp;
new = createnode();
if(*h == NULL)
{
*h = new;
return;
}
temp = *h;
while(temp->next!=NULL)
temp = temp->next;
temp->next = new;
new->prev = temp;
}

void forward_display(struct node *p)

{
printf("\nContents of the List : \n\n");
while(p!=NULL)
{
printf("\t%d",p->data);
p = p->next;
}
printf("\n");
}
void insert_after(struct node **h) {
struct node *new,*temp;
int k;
if(*h == NULL) return;
printf("\nEnter data of node after which node : ");
scanf("%d",&k);
temp = *h;
while(temp!=NULL && temp->data!=k)
temp = temp->next;
if(temp!=NULL) {
new=createnode();
new->next = temp->next;
temp->next = new;
new->prev = temp;
if(new->next != NULL)
new->next->prev = new;
}
}

Implementing Doubly Linked List ( continued )

void insert_before(struct node **h)
{
struct node *new,*temp;
int k;
if(*h==NULL) return;
printf("\nEnter data of node before which node : ");
scanf("%d",&k);
if((*h)->data == k) {
new = createnode();
new->next = *h;
new->next->prev=new;
*h = new;
return;
}
temp = *h;
while(temp!=NULL && temp->data!=k)
{
temp=temp->next;
}
if(temp!=NULL)
{
new = createnode();
new->next = temp;
new->prev = temp->prev;
new->prev->next = new;
temp->prev = new;
}
}

void delnode(struct node **h)

{
struct node *temp;
int k;
if(*h==NULL)
return;
printf("\nEnter the data of node to be removed : ");
scanf("%d",&k);
if((*h)->data==k)
{
temp=*h;
*h=(*h)->next;
(*h)->prev=NULL;
free(temp);
return;
}
temp=*h;
while(temp!=NULL && temp->data!=k)
{
temp=temp->next;
}
if(temp!=NULL)
{
temp->next->prev = temp->prev;
temp->prev->next = temp->next;
free(temp);
}
}

Implementing Doubly Linked List ( continued )

void search(struct node *h)
{
struct node *temp;
int k;
if(h==NULL)
return;
printf("\nEnter the data to be searched : ");
scanf("%d",&k);
temp=h;
while(temp!=NULL && temp->data!=k)
temp=temp->next;
if (temp==NULL)
printf("\n\t=>Node does not exist")
else
printf("\n\t=>Node exists");
}
void destroy(struct node **h)
{
struct node *p;
if(*h==NULL) return;
while(*h!=NULL)
{
p = (*h)->next;
free(*h);
*h=p;
}
printf("\n\n ******Linked List is destroyed******");
}

int main() {
struct node *head=NULL;
int ch;
while(1) {
printf("\n1.Append");
printf("\n2.Display All");
printf("\n3.Insert after a specified node");
printf("\n4.Insert before a specified node");
printf("\n5.Delete a node");
printf("\n6.Search for a node");
printf("\n7.Distroy the list");
printf("\n8.Exit program");
printf("\n\n\tEnter your choice : ");
scanf("%d",&ch);
switch(ch) {
case 1:append(&head);break;
case 2:forward_display(head);break;
case 3:insert_after(&head);break;
case 4:insert_before(&head);break;
case 5:delnode(&head);break;
case 6:search(head);break;
case 7:destroy(&head);break;
case 8:exit(0);break;
default :
printf("Wrong Choice, Enter correct choice :
");
}
}
}

101

Circular Singly
Linked List

400

150
n1-node

102

720

400
n2-node

103

910

104 150

720
n3-node

910
n4-node

910
tail

-- Singly Linked List has a major drawback. From a specified node, it is not possible to reach any of
the preceding nodes in the list. To overcome the drawback, a small change is made to the SLL so that
the next field of the last node is pointing to the first node rather than NULL. Such a linked list is called a
circular linked list.
-- Because it is a circular linked list, it is possible to reach any node in the list from a particular node.
-- There is no natural first node or last node because by virtue of the list is circular.
-- Therefore, one convention is to let the external pointer of the circular linked list, tail, point to the last
node and to allow the following node to be the first node.
-- If the tail pointer refers to NULL, means the circular linked list is empty.

Circular Doubly Linked List

prev

data

next

prev

data

next

prev

data

next

prev

data

next

-- A Circular Doubly Linked List ( CDL ) is a doubly linked list with first node linked to last node and
vice-versa.
-- The prev link of first node contains the address of last node and next link of last node contains
the address of first node.
-- Traversal through Circular Singly Linked List is possible only in one direction.
-- The main advantage of Circular Doubly Linked List ( CDL ) is that, a node can be inserted into list
without searching the complete list for finding the address of previous node.
-- We can also traversed through CDL in both directions, from first node to last node and vice-versa.

Implementing Circular Singly Linked List

struct node {
int data; struct node *next;
};
struct node *createnode() {
struct node *new;
new = (struct node *)malloc(sizeof(struct node));
printf("\nEnter the data : ");
scanf("%d",&new->data);
new->next = NULL;
return new;
}
void append(struct node **t) {
struct node *new,*head;
new = createnode();
if(*t == NULL) {
*t = new; new->next = *t;
return;
}
head = (*t)->next; (*t)->next = new;
new->next = head; *t = new;
}
void display(struct node *t) {
struct node *temp = t->next, *head=t->next;
printf("\nContents of the List : \n\n");
do {
printf("\t%d",temp->data);temp = temp->next;
}while(temp!=head);
printf(\n);
}

void insert_after(struct node **t)

{
struct node *new,*temp;
int k, found=0;
if(*t == NULL) return;
printf("\nEnter data of node after which node : ");
scanf("%d",&k);
if((*t)->data==k)
{
new = createnode();
new->next = (*t)->next;
(*t)->next = new;
*t=new;
return;
}
temp=(*t)->next;
while(temp!=*t)
{
if(temp->data == k)
{
new = createnode();
new->next = temp->next;
temp->next = new;
found=1;
break;
}
temp=temp->next;
}
if(found==0) printf("\nNode does not exist..");
}

Implementing Circular Singly Linked List ( continued )

void insert_before(struct node **t) {
struct node *new,*temp,*prev,*head;
int k,found=0;
if(*t==NULL) return;
printf("\nEnter data of node before which node :
");
scanf("%d",&k);
head=(*t)->next;
if(head->data == k) {
new = createnode();
new->next = head;
(*t)->next = new;
return;
}
temp = head->next;
prev = head;
while(temp!=head) {
if(temp->data==k) {
new = createnode();
prev->next = new;
new->next = temp;
found=1;
break;
} else {
prev=temp;
temp=temp->next;
}
}
if(found==0) printf("\nNode does not exist..");

void delnode(struct node **t) {

struct node *temp,*prev,*head;
int k,found=0;
if(*t==NULL) return;
printf("\nEnter the data of node to be removed :
");
scanf("%d",&k);
head=(*t)->next;
if(head->data==k) {
temp=head;
if(temp->next!=head) (*t)->next=head->next;
else *t = NULL;
free(temp);
return;
}
temp=head->next; prev=head;
while(temp!=head) {
if(temp->data == k) {
prev->next = temp->next;
if(temp==*t) *t = prev;
free(temp);
found=1;
break;
} else {
prev=temp;
temp=temp->next;
}
}
if(found==0) printf("\nNode does not exist..");

Implementing Circular Singly

Linked List ( continued )
int main() {
struct node *tail=NULL;
int ch;
while(1) {
printf("\n1.Append");
printf("\n2.Display All");
printf("\n3.Insert after a specified node");
printf("\n4.Insert before a specified node");
printf("\n5.Delete a node");
printf("\n6.Exit program");
printf("\n\n\tEnter your choice : ");
scanf("%d",&ch);
switch(ch)
{
case 1:append(&tail);break;
case 2:display(tail);break;
case 3:insert_after(&tail);break;
case 4:insert_before(&tail);break;
case 5:delnode(&tail);break;
case 6:exit(0);break;
default :
printf(\n\tWrong Choice );
}
}
}

Types of Data Structures

Data structures are classified in several ways :

Linear : Elements are arranged in sequential
fashion. Ex : Array, Linear list, stack, queue
Non-Linear : Elements are not arranged in
sequence. Ex : trees, graphs
Homogenous : All Elements are belongs to same
data type. Ex : Arrays
Non-Homogenous : Different types of Elements
are grouped and form a data structure. Ex:
classes
Dynamic : Memory allocation of each element in
the data structure is done before their usage
using D.M.A functions Ex : Linked Lists
Static : All elements of a data structure are
created at the beginning of the program. They
cannot be resized. Ex : Arrays

Stacks
-- Stack is an ordered collection of data elements into which new elements may be inserted and from
which elements may be deleted at one end called the TOP of stack.
-- A stack is a last-in-first-out ( LIFO ) structure.
-- Insertion operation is referred as PUSH and deletion operation is referred as POP.
-- The most accessible element in the stack is the element at the position TOP.
-- Stack must be created as empty.
-- Whenever an element is pushed into stack, it must be checked whether the stack is full or not.
-- Whenever an element is popped form stack, it must be checked whether the stack is empty or not.
-- We can implement the stack ADT either with array or linked list.

Applications of stack
Reversing Data series
Conversion decimal to binary
Parsing into tokens
Backtracking the operations
Undo operations in Text Editor
Page visited History in web browser
Tracking of Function calls
Maintaining scope and lifetime of local
variables in functions
Infix to postfix conversion
Evaluating postfix expression

Stack ADT
struct stackNode {
int data; struct stackNode *next;
};
init_stack( )
push ( )
pop ( )
isEmpty ( )
display ( )
peek ( )

Push(a) Push(b) Push(c)

Pop( ) Push(d) Push(e)

Pop( )

Pop( )

Pop( )

e
c
a

Operations on Stack
Operation
1. Init_stack( )
2. Push( a )
3. Push( b )
4. Push( c )
5. Pop( )
6. Push( d )
7. Push( e )
8. Pop( )
9. Pop( )
10. Pop( )
11. Pop( )

Stacks contents
<empty>
a
ab
abc
ab
abd
abde
abd
ab
a
<empty>

TOP value
-1
0
1
2
1
2
3
2
1
0
-1

Output

c
c
c
ce
ced
cedb
cedba

Pop( )

Implementing Stack ADT using Array

#define SIZE 50
int stack[SIZE]; int top;
void init_stack() {
top=-1;
}
void push( int n ) {
if( top==SIZE-1) printf("\nStack is full");
else stack[++top]= n;
}
int pop( ) {
if(top== -1) {
printf("\nStack is empty");
return -1;
} else return stack[top--];
}
void display( ) {
int i;
if(top== -1) printf("\nStack is empty.");
else {
printf("\nElements are : \n");
for(i=0;i<=top;i++)
printf("%5d ",stack[i]);
}
}
int isEmpty( ) {
if ( top== -1 ) return 1;
else return 0;
}
int peek( ){ return stack[top]; }

int main() {
int choice,item;
init_stack();
do
{
printf("\n\t\t\tMenu\n\t1.Push.\n\t2.Pop.");
printf("\n\t3.Peek.\n\t4.Display.\n\t5.Exit.\n");
printf("\nYour Choice: ");
scanf("%d",&choice);
switch(choice)
{
case 1:printf("\nEnter the element to push :
");
scanf("%d",&item);
push(item); break;
case 2:item = pop();
printf("\nElement poped : %d",item);
printf("\nPress a key to continue...");
getche(); break;
case 3:item = peek();
printf("\nElement at top : %d",item);
printf("\nPress a key to continue...");
getche(); break;
case 4:display();
printf("\nPress a key to continue...");
getche(); break;
case 5:exit(0);
}

Implementing Stack ADT using Linked List

struct s_node {
int data;
struct s_node *link;
} *stack;
void push(int j) {
struct s_node *m;
m=(struct s_node*)malloc(sizeof(struct s_node));
m->data= j ; m->link=stack;
stack=m; return;
}
int pop( ) {
struct s_node *temp=NULL;
if(stack==NULL) {
printf("\nSTACK is Empty."); getch();
} else {
int i=stack->data;
temp = stack ; stack=stack->link;
free(temp); return (i);
}
}
int peek( ) {
if(stack==NULL) {
printf("\nSTACK is Empty."); getch();
} else
return (stack->data);
}
void display() {
struct s_node *temp=stack;

while(temp!=NULL) {
printf("%d\t",temp->data);
temp=temp->link;
}
}
void main() {
int choice,num,i;
while(1) {
printf("\n\t\t MENU\n1. Push\n2. Pop\n3. Peek");
printf("\n4. Elements in Stack\n5. Exit\n");
printf("\n\tEnter your choice: ");
scanf("%d",&choice);
switch(choice) {
case 1: printf("\nElement to be pushed:");
scanf("%d",&num);
push(num); break;
case 2: num=pop();
printf("\nElement popped: %d ",num);
getch(); break;
case 3: num=peek();
printf("\nElement peeked : %d ",num);
getch(); break;
case 4: printf("\nElements present in stack : ):
display();getch(); break;
case 5: exit(1);
default: printf("\nInvalid Choice\n"); break;
}
}
}

Queues
-- Queue is a linear data structure that permits insertion of new element at one end and deletion of an
element at the other end.
-- The end at which insertion of a new element can take place is called rear and the end at which
deletion of an element take place is called front .
-- The first element that gets added into queue is the first one to get removed from the list, Hence
Queue is also referred to as First-In-First-Out ( FIFO ) list.
-- Queue must be created as empty.
-- Whenever an element is inserted into queue, it must be checked whether the queue is full or not.
-- Whenever an element is deleted form queue, it must be checked whether the queue is empty or
not.
-- We can implement the queue ADT either with array or linked list.

rear

front

addq (4)

5
delq ( )

Queue ADT
struct queueNode {
int data; struct queueNode *next;
};
init_queue( )
addq ( )
delq ( )
isEmpty ( )
printQueue ( )

Applications of Queues
Execution of Threads
Job Scheduling
Event queuing
Message Queueing

Types of Queues
circular queues
priority queues
double-ended queues

Implementing Queue ADT using Array

int queue[10] ,front, rear ;
void init_queue() {
front = rear = -1 ;
}
void addq ( int item ){
if ( rear == 9 ) {
printf("\nQueue is full");
return ;
}
rear++ ;
queue [ rear ] = item ;
if ( front == -1 )front = 0 ;
}
int delq( ){
int data ;
if ( front == -1 ) {
printf("\nQueue is Empty");
return 0;
}
data = queue[front] ;
queue[front] = 0 ;
if ( front == rear ) front = rear = -1 ;
else front++ ;
return data ;
}
void display() {
int i;
if(front==-1) printf("\nQueue is empty.");
else {

printf("\nElements are : \n");

for (i=front;i<=rear;i++)
printf("%5d",queue[i]);
}
}
int main() {
int ch,num;
init_queue();
do
{
printf("\n\tMENU\n\n1. Add to Queue);
printf(\n2. Delete form Queue");
printf("\n3. Display Queue\n4. Exit.");
printf("\n\n\tYour Choice: ");
scanf("%d",&ch);
switch(ch)
{
case 1: printf("\nEnter an element : ");
scanf("%d",&num);
addq(num);break;
case 2: num=delq();
printf("\nElement deleted : %d",num);
break;
case 3: display(); break;
case 4: exit(0);
default: printf("\nInvalid option..");
}
}while(1);
}

Implementing Queue ADT using Liked List

struct q_node {
int data; struct q_node *next;
}*rear,*front;
void init_queue() {
rear=NULL; front=NULL;
}
void addq(int item) {
struct q_node *t;
t=(struct q_node*)malloc(sizeof(struct q_node));
t->data=item; t->next=NULL;
if(front==NULL) rear=front=t;
else {
rear->next=t; rear=rear->next;
}
}
int delq() {
struct q_node *temp;
if(front==NULL) {
printf("\nQueue is empty."); return 0;
} else {
int num = front->data;
temp = front; front=front->next;
free(temp); return num;
}
}
void display() {
struct q_node *temp=front;
if(front==NULL) printf("\nQueue is empty.");

else {
printf("\nElements in Queue :\n");
while(temp!=NULL) {
printf("%5d",temp->data);
temp=temp->next;
}
}
}
int main() {
int ch,num;
init_queue();
do {
printf("\n\tMENU\n\n1. Add\n2. Delete");
printf("\n3. Display Queue\n4. Exit.");
printf("\n\n\tYour Choice: ");
scanf("%d",&ch);
switch(ch) {
case 1: printf("\nEnter an element : ");
scanf("%d",&num);
addq(num);break;
case 2: num=delq();
printf("\nElement deleted : %d",num); break;
case 3: display(); break;
case 4: exit(0);
default:printf("\nInvalid option..");
}
}while(1);
}

--Arithmetic Expressions are represented using three notations infix, prefix and postfix. The prefixes
pre, post, and in refer to position of operators with respect to two operands.
-- In infix notation, the operator is placed between the two operands.
Ex: A + B
A*B+C
(A * B) + (C * D)
-- In Prefix notation, the operator is placed before the two operands.
Ex: +AB
*A+BC
+*AB*CD
-- In Postfix notation, the operator is placed after the two operands.
Ex: AB+
ABC+*
AB*CD*+

Algorithm to Infix to Postfix Conversion

In-To-Post ( infix-expression )
Scan the Infix expression left to right
If the character x is an operand
Output the character into the Postfix Expression
If the character x is a left or right parenthesis
If the character is (
Push it into the stack
If the character is )
Repeatedly pop and output all the operators/characters until ( is popped from the stack.
If the character x is a is a regular operator
Check the character y currently at the top of the stack.
If Stack is empty or y is ( or y is an operator of lower precedence than x, then
Push x into stack.
If y is an operator of higher or equal precedence than x,
Pop and output y and push x into the stack.
When all characters in infix expression are processed
repeatedly pop the character(s) from the stack and output them until the stack is empty.

In-Fix To Post-Fix convertion

#define STACKSIZE 20
typedef struct {
int top; char items[STACKSIZE];
}STACK;
/*pushes ps into stack*/
void push(STACK *sptr, char ps) {
if(sptr->top == STACKSIZE-1) {
printf("Stack is full\n"); exit(1);
} else
sptr->items[++sptr->top]= ps;
}
char pop(STACK *sptr) {
if(sptr->top == -1) {
printf("Stack is empty\n"); exit(1);
} else
return sptr->items[sptr->top--];
}
int main() {
int i; STACK s; char x, y, E[20] ;
s.top = -1; /* Initialize the stack is */
printf("Enter the Infix Expression:");
scanf("%s",E);
for(i=0;E[i] != '\0';i++) {
x= E[i];
/* Consider all lowercase letter
from a to z are operands */
if(x<='z' && x>='a') printf("%c",x);
else if(x == '(') push(&s ,x);
else if( x == ') ){

y=pop(&s) ;
while(y != '(') {
printf("%c",y);
y=pop(&s) ;
}
} else {
if(s.top ==-1 || s.items[s.top] == '(')
push(&s ,x);
else {
/* y is the top operator in the stack*/
y = s.items[s.top];
/* precedence of y is higher/equal to x*/
if( y=='*' || y=='/'){
printf("%c", pop(&s));
push(&s ,x);
} else if ( y=='+' || y=='-')
/* precedence of y is equal to x*/
if( x=='+' || x=='-') {
printf("%c", pop(&s));
push(&s ,x);
}
/* precedence of y is less than x*/
else
push(&s ,x);
}
}
}
while(s.top != -1) printf("%c",pop(&s));
}

Evaluation of Post-Fix Expression

#include<stdio.h>
#include<ctype.h>
#include<math.h>
float stack[10];
int top=-1;
void push(char c)
{
stack[++top]=c;
}
float pop() {
float n;
n=stack[top--];
return (n);
}
float evaluate(char expr[], float data[])
{
int j=0;
float op1=0,op2=0;
char ch;
while(expr[j]!='\0') {
ch = expr[j];
if(isalpha(expr[j]))
{
push(data[j]);
} else {
op2=pop();
op1=pop();
switch(ch) {
case '+':push(op1+op2);break;
case '-':push(op1-op2);break;

case '*':push(op1*op2);break;
case '/':push(op1/op2);break;
case '^':push(pow(op1,op2));
break;
}
}
j++;
}
return pop();
}
int main() {
int j=0;
char expr[20];
float number[20],result;
printf("\nEnter a post fix expression : ");
gets(expr);
while(expr[j]!='\0')
{
if(isalpha(expr[j]))
{
fflush(stdin);
printf("\nEnter number for %c : ",expr[j]);
scanf("%f",&number[j]);
}
j++;
}
result = evaluate(expr,number);
printf("\nThe result of %s is %f",expr,result);
}

FaaDoOEngine
ers.com
Engaging Peers, Inspiring Careers!

Indias No.1 website for:

IIT-JEE/AIEEE preparation resources

Coaching centre packages
Engineering Major and Minor projects
Seminar reports
Paper presentations
EBOOKS
Resumes/CVs, and so much more