Lab Practical No.

– 1

1. Program of Matrix multiplication

#include <stdio.h>

#define M 10 // the matrices are MxP, PxN and MxN.

#define P 7
#define N 8

void ftrans( int a[][3], int b[][3] ) {

/*
* finds fast-transpose of a in b.
*/
int t[P+1];
int i, j, n, terms;
int temp, temp2;

n = a[0][1];
terms = a[0][2];
b[0][0] = n;
b[0][1] = a[0][0];
b[0][2] = terms;

if( terms <= 0 )

return;
for( i=0; i<n; ++i )
t[i] = 0;
for( i=1; i<=terms; ++i )
t[a[i][1]]++;
temp = t[0];
t[0] = 1;
for( i=1; i<n; ++i ) {
temp2 = t[i], t[i] = t[i-1]+temp, temp = temp2;
}
for( i=1; i<=terms; ++i ) {
j = t[a[i][1]];
b[j][0] = a[i][1], b[j][1] = a[i][0], b[j][2] = a[i][2];
t[a[i][1]] = j+1;
}
}

void printMatrix( int a[][3] ) {

/*
* prints the matrix in the form of 3-tuples.
*/
 int i;
int nterms = a[0][2];

printf( "rows=%d cols=%d vals=%d.\n", a[0][0], a[0][1], a[0]

[2] );
for( i=1; i<=nterms; ++i )
printf( "a[%d][%d] = %d.\n", a[i][0], a[i][1], a[i][2] );
putchar( '\n' );
}
void insert( int c[][3], int row, int col, int val ) {
/*
* insert or add the triplet (row,col,val) in c.
* update c[0][2] if necessary.
*/
int i, terms = c[0][2];

for( i=1; i<=terms && c[i][0]<row; ++i )

;
for( ; i<=terms && c[i][1]<col; ++i )
;
if( i<=terms && c[i][1] == col ) // already inserted.
c[i][2] += val;
else { // a new
entry should be inserted at i.
c[i][0] = row; c[i][1] = col; c[i][2] = val;
c[0][2]++;
}
}

void mmult( int a[][3], int b[][3], int c[][3] ) {

/*
* c = a*b;
*/
int i, j, mn = M*N;
int aterms = a[0][2], bterms = b[0][2];
int rowsofb = b[0][0];
int *t = (int *)malloc( rowsofb*sizeof(int) );
int temp, temp2;
int arow, acol, aval, brow, browstart, browend;

c[0][0] = a[0][0];
c[0][1] = b[0][1];

// init c.
for( i=0; i<=mn; ++i )
c[i][2] = 0;
 // fill t[] : t[i] points to row of b where actual row i
starts.
// last+1 entry is also maintained for easing loops.
for( i=0; i<=rowsofb; ++i )
t[i] = 0;
for( i=1; i<=bterms; ++i )
t[b[i][0]]++;
temp = t[0];
t[0] = 1;
for( i=1; i<=rowsofb; ++i )
temp2 = t[i], t[i] = t[i-1]+temp, temp = temp2;

// now start mult.

for( i=1; i<=aterms; ++i ) {
arow = a[i][0]; acol = a[i][1]; aval = a[i][2];
brow = acol;
browstart = t[brow]; browend = t[brow+1];
for( j=browstart; j<browend; ++j )
insert( c, arow, b[j][1], aval*b[j][2] );
}
}

int main() {
int a[][3] = {
{4,2,3},
{0,1,2},
{1,0,3},
{3,1,4}
};
int b[][3] = {
{2,3,3},
{0,2,5},
{1,0,7},
{1,1,6}
};
int c[M*N+1][3];

printMatrix(a);
printMatrix(b);
mmult( a, b, c );
printMatrix(c);

return 0;
}
 Lab Practical No. – 2

2. Program of Sparse Matrix

# include <stdio.h>
# include <stdlib.h>
struct snode
{
int row,col,val;
struct snode *link;
};

struct snode *insert(struct snode *, int,int,int);

void printlist ( struct snode * );
struct snode *sadd(struct snode *, struct snode *);
//struct pnode *sortlist(struct pnode *);

struct snode *insert(struct snode *p, int r,int c,int val)

{
struct snode *temp;
if(p==NULL)
{
p=(struct snode *)malloc(sizeof(struct snode));
if(p==NULL)
{
printf("Error\n");
exit(0);
}
p->row = r;
p->col = c;
p->val = val;
p-> link = NULL;
}
else
{
temp = p;
while (temp-> link!= NULL)
temp = temp-> link;
temp-> link = (struct snode *)malloc(sizeof(struct snode));
if(temp -> link == NULL)
{
printf("Error\n");
exit(0);
}
temp = temp-> link;
temp-> row = r;
 temp->col= c;
temp->val=val;
temp-> link = NULL;
}
return (p);
}

/* A function to add two sparse matrices */

struct snode *sadd(struct snode *p, struct snode *q)
{
struct snode *r = NULL;
int val;
while((p!=NULL) && (q != NULL))
{
if(p->row < q->row)
{
r = insert(r,p->row,p->col,p->val);
p = p->link;
}
else
if(p->row > q->row)
{
r = insert(r,q->row,q->col,q->val);
q = q->link;
}
else
if( p->col < q->col)
{
r = insert(r,p->row,p->col,p->val);
p = p->link;
}
else
if(p->col > q->col)
{
r = insert(r,q->row,q->col,q->val);
q = q->link;
}
else
{
val = p->val + q->val;
r = insert( r, p->row,p->col,val);
p = p->link;
q = q->link;
}
}
while(p != NULL)
{
 r = insert( r, p->row ,p->col,p->val);
p = p->link;
}
while(q!=NULL)
{
r = insert( r, q->row ,q->col,q->val);
q = q->link;
}
return(r);
}

void printlist ( struct snode *p )

{
printf("The resultant sparse matrix is\n");
while (p!= NULL)
{
printf("%d %d % d\n",p-> row,p->col,p->val);
p = p-> link;
}
}
void main()
{
int r,n,c,val;
struct snode *s1 = NULL ;
struct snode *s2=NULL;
struct snode *result = NULL;
printf("Enter the number of non-zero terms in the sparse
matrix1 \n");
scanf("%d",&n);
printf("Enter the terms in the sparse matrix1 in the
increasing
order of row indices and for the same row index in the increasing
order of
row indices and for the same row index in the increasing order of
column
indices \n");
while ( n-- > 0 )
{
printf( "Enter the row number, column number, and
value\n");
scanf("%d %d%d",&r,&c,&val);
s1 = insert ( s1,r,c,val);
}
printf("Enter the number of non-zero terms in the sparse
matrix1 \n");
scanf("%d",&n);
 printf("Enter the terms in the sparse matrix2 in the
increasing
order of row indices and for the same row index in the increasing
order of
row indices and for the same row index in the increasing order of
column
indices \n");
while ( n-- > 0 )
{
printf( "Enter the row number, column number, and
value\n");
scanf("%d %d%d",&r,&c,&val);
s2 = insert ( s2,r,c,val);
}
result = sadd(s1,s2);
printf("The result of addition is\n");
printlist ( result );
}
 Lab Practical No. – 3

3. Program of Linear Search

#include <stdio.h>
#define MAX 10
void lsearch(int list[],int n,int element)
{
int i, flag = 0;
for(i=0;i<n;i++)
if( list[i] == element)
{
printf(" The element whose value is %d is present at
position %d
in list\n",
element,i);
flag =1;
break;
}
if( flag == 0)
printf("The element whose value is %d is not present in
the
list\n",
element);
}

void readlist(int list[],int n)

{
int i;
printf("Enter the elements\n");
for(i=0;i<n;i++)
scanf("%d",&list[i]);
}

void printlist(int list[],int n)

{
int i;
printf("The elements of the list are: \n");
for(i=0;i<n;i++)
printf("%d\t",list[i]);
}
void main()
{
int list[MAX], n, element;
printf("Enter the number of elements in the list max = 10\n");
scanf("%d",&n);
 readlist(list,n);
printf("\nThe list before sorting is:\n");
printlist(list,n);
printf("\nEnter the element to be searched\n");
scanf("%d",&element);
lsearch(list,n,element);
}

Lab Practical No. – 4

4. Program of Binary Search
#include <stdio.h>
#define MAX 10

void bsearch(int list[],int n,int element)

{
int l,u,m, flag = 0;
l = 0;
u = n-1;
while(l <= u)
{
m = (l+u)/2;
if( list[m] == element)
{
printf(" The element whose value is %d is present
at
position %d in list\n",
element,m);
flag =1;
break;
}
else
if(list[m] < element)
l = m+1;
else
u = m-1;
}
if( flag == 0)
printf("The element whose value is %d is not present in the
list\n",
element);
}

void readlist(int list[],int n)

{
int i;
printf("Enter the elements\n");
for(i=0;i<n;i++)
scanf("%d",&list[i]);
}

void printlist(int list[],int n)

{
int i;
printf("The elements of the list are: \n");
 for(i=0;i<n;i++)
printf("%d\t",list[i]);
}

void main()
{
int list[MAX], n, element;
printf("Enter the number of elements in the list max = 10\n");
scanf("%d",&n);
readlist(list,n);
printf("\nThe list before sorting is:\n");
printlist(list,n);
printf("\nEnter the element to be searched\n");
scanf("%d",&element);
bsearch(list,n,element);
}

Lab Practical No. – 5

5. Program of Merge Sort
#include <stdio.h>
#define MAX 10
void merge(int list[],int list1[],int k,int m,int n)
{
int i,j;
i=k;
j = m+1;
while( i <= m && j <= n)
{
if(list[i] <= list[j])
{
list1[k] = list[i];
i++;
k++;
}
else
{
list1[k] = list[j];
j++;
k++;
}
}
while(i <= m)
{
list1[k] = list[i];
i++;
k++;
}
while (i <= n )
{
list1[k] = list[j];
j++;
k++;
}
}

void mpass( int list[],int list1[],int l,int n)

{
int i;
i = 0;
while( i <= (n-2*l+1))
{
merge(list,list1,i,(i+l-1),(i+2*l-1));
i = i + 2*l;
}
 if((i+l-1) < n)
merge(list,list1,i,(i+l-1),n);
else
while (i <= n )
{
list1[i] = list[i];
i++;
}
}
void msort(int list[], int n )
{
int l;
int list1[MAX];
l =1;
while (l <= n )
{
mpass(list,list1,l,n);
l = l*2;
mpass(list1,list,l,n);
l = l*2;
}
}

void readlist(int list[],int n)

{
int i;
printf("Enter the elements\n");
for(i=0;i<n;i++)
scanf("%d",&list[i]);
}

void printlist(int list[],int n)

{
int i;
printf("The elements of the list are: \n");
for(i=0;i<n;i++)
printf("%d\t",list[i]);
}

void main()
{
int list[MAX], n;
printf("Enter the number of elements in the list max = 10\n");
scanf("%d",&n);
readlist(list,n);
printf("The list before sorting is:\n");
printlist(list,n);
 msort(list,n-1);
printf("The list after sorting is:\n");
printlist(list,n);
}

Lab Practical No. – 6

6. Program of Quick Sort

#include <stdio.h>
#define MAX 10
void swap(int *x,int *y)
{
int temp;
temp = *x;
*x = *y;
*y = temp;
}
int getkeyposition(int i,int j )
{
return((i+j) /2);
}
void qsort(int list[],int m,int n)
{
int key,i,j,k;
if( m < n)
{
k = getkeyposition(m,n);
swap(&list[m],&list[k]);
key = list[m];
i = m+1;
j = n;
while(i <= j)
{
while((i <= n) && (list[i] <= key))
i++;
while((j >= m) && (list[j] > key))
j-;
if( i < j)
swap(&list[i],&list[j]);
}
swap(&list[m],&list[j]);
qsort(list[],m,j-l);
qsort(list[],j+1,n);
}
}
void readlist(int list[],int n)
{
int i;
printf("Enter the elements\n");
for(i=0;i<n;i++)
scanf("%d",&list[i]);
}
void printlist(int list[],int n)
{
 int i;
printf("The elements of the list are: \n");
for(i=0;i<n;i++)
printf("%d\t",list[i]);
}

void main()
{
int list[MAX], n;
printf("Enter the number of elements in the list max = 10\n");
scanf("%d",&n);
readlist(list,n);
printf("The list before sorting is:\n");
printlist(list,n);
qsort(list,0,n-1);
printf("\nThe list after sorting is:\n");
printlist(list,n);
}

Lab Practical No. – 7

7. Program of Heap Sort

#include <stdio.h>
#define MAX 10
void swap(int *x,int *y)
{
int temp;
temp = *x;
*x = *y;
*y = temp;
}

void adjust( int list[],int i, int n)

{
int j,k,flag;
k = list[i];
flag = 1;
j = 2 * i;
while(j <= n && flag)
{
if(j < n && list[j] < list[j+1])
j++;
if( k >= list[j])
flag =0;
else
{
list[j/2] = list[j];
j = j *2;
}
}
list [j/2] = k;
}

void build_initial_heap( int list[], int n)

{
int i;
for(i=(n/2);i>=0;i-)
adjust(list,i,n-1);
}

void heapsort(int list[],int n)

{
int i;
build_initial_heap(list,n);
for(i=(n-2); i>=0;i-)
{
swap(&list[0],&list[i+1]);
adjust(list,0,i);
}
}
void readlist(int list[],int n)
{
int i;
printf("Enter the elements\n");
for(i=0;i<n;i++)
scanf("%d",&list[i]);
}

void printlist(int list[],int n)

{
int i;
printf("The elements of the list are: \n");
for(i=0;i<n;i++)
printf("%d\t",list[i]);
}

void main()
{
int list[MAX], n;
printf("Enter the number of elements in the list max = 10\n");
scanf("%d",&n);
readlist(list,n);
printf("The list before sorting is:\n");
printlist(list,n);
heapsort(list,n);
printf("The list after sorting is:\n");
printlist(list,n);
}

Lab Practical No. – 8

8. Program of Single Linked List

# include <stdio.h>
# include <stdlib.h>
 struct node
{
int data;
struct node *link;
};
struct node *insert(struct node *p, int n)
{
struct node *temp;
/* if the existing list is empty then insert a new node as the
starting node */
if(p==NULL)
{
p=(struct node *)malloc(sizeof(struct node)); /* creates
new node
data value passes
as parameter */

if(p==NULL)
{
printf("Error\n");
exit(0);
}
p-> data = n;
p-> link = p; /* makes the pointer pointing to itself
because it
is a circular list*/
}
else
{
temp = p;
/* traverses the existing list to get the pointer to the last
node of
it */
while (temp-> link != p)
temp = temp-> link;
temp-> link = (struct node *)malloc(sizeof(struct
node)); /*
creates new node using
data value passes as
parameter and puts its
address in the link field
of last node of the
existing list*/
if(temp -> link == NULL)
{
printf("Error\n");
exit(0);
 }
temp = temp-> link;
temp-> data = n;
temp-> link = p;
}
return (p);
}
void printlist ( struct node *p )
{
struct node *temp;
temp = p;
printf("The data values in the list are\n");
if(p!= NULL)
{
do
{
printf("%d\t",temp->data);
temp=temp->link;
} while (temp!= p);
}
else
printf("The list is empty\n");
}
void main()
{
int n;
int x;
struct node *start = NULL ;
printf("Enter the nodes to be created \n");
scanf("%d",&n);
while ( n -- > 0 )
{
printf( "Enter the data values to be placed in a node\n");
scanf("%d",&x);
start = insert ( start, x );
}
printf("The created list is\n");
printlist ( start );
}
Lab Practical No. – 9

9. Program of Single Circular Linked List

# include <stdio.h>
# include <stdlib.h>
struct node
{
int data;
struct node *link;
};
struct node *insert(struct node *p, int n)
{
struct node *temp;
/* if the existing list is empty then insert a new node as the
starting node */
if(p==NULL)
{
p=(struct node *)malloc(sizeof(struct node)); /* creates
new
node data value passes
as parameter */
if(p==NULL)
{
printf("Error\n");
exit(0);
}
p-> data = n;
p-> link = p; /* makes the pointer pointing to itself
because it
is a circular list*/
}
else
{
temp = p;
/* traverses the existing list to get the pointer to the last
node of
it */
while (temp-> link != p)
temp = temp-> link;
temp-> link = (struct node *)malloc(sizeof(struct
node)); /*
creates new node using
data value passes as
parameter and puts its
address in the link field
of last node of the
existing list*/
if(temp -> link == NULL)
{
printf("Error\n");
}
exit(0);
temp = temp-> link;
 temp-> data = n;
temp-> link = p;
}
return (p);
}
void printlist ( struct node *p )
{
struct node *temp;
temp = p;
printf("The data values in the list are\n");
if(p!= NULL)
{
do
{
printf(%d\t",temp->data);
temp=temp->link;
} while (temp!= p)
}
else
printf("The list is empty\n");
}
void main()
{
int n;
int x;
struct node *start = NULL ;
printf("Enter the nodes to be created \n");
scanf("%d",&n);
while ( n- > 0 )
{
printf( "Enter the data values to be placed in a
node\n");
scanf("%d",&x);
start = insert ( start, x );
}
printf("The created list is\n");
printlist ( start );
}
Lab Practical No. – 10

10. Program of Doubly Linked List

# include <stdio.h>
# include <stdlib.h>
struct dnode
{
 int data;
struct dnode *left, *right;
};
struct dnode *insert(struct dnode *p, struct dnode **q, int n)
{
struct dnode *temp;
/* if the existing list is empty then insert a new node as the
starting node */
if(p==NULL)
{
p=(struct dnode *)malloc(sizeof(struct dnode)); /*
creates new
node data value
passed as parameter */

if(p==NULL)
{
printf("Error\n");
exit(0);
}
p->data = n;
p-> left = p->right =NULL;
*q =p;
}
else
{
temp = (struct dnode *)malloc(sizeof(struct dnode));
/* creates new node using data value passed as parameter and puts
its address in the temp */
if(temp == NULL)
{
printf("Error\n");
exit(0);
}
temp->data = n;
temp->left = (*q);
temp->right = NULL;
(*q)->right = temp;
(*q) = temp;
}
return (p);
}
void printfor( struct dnode *p )
{
printf("The data values in the list in the forward order
are:\n");
while (p!= NULL)
 {
printf("%d\t",p-> data);
p = p->right;
}
}
void printrev( struct dnode *p )
{
printf("The data values in the list in the reverse order
are:\n");
while (p!= NULL)
{
printf("%d\t",p->data);
p = p->left;
}
}
void main()
{
int n;
int x;
struct dnode *start = NULL ;
struct dnode *end = NULL;
printf("Enter the nodes to be created \n");
scanf("%d",&n);
while ( n-- > 0 )
{
printf( "Enter the data values to be placed in a node\n");
scanf("%d",&x);
start = insert ( start, &end,x );
}
printf("The created list is\n");
printfor ( start );
printrev(end);
}

Lab Practical No. – 11

11. Program of Double Circular Linked List

#include< stdio.h >
#include< stdlib.h >
struct list
{
int num;
struct list *next;
struct list *prev;
};
struct list *node;
void create(struct list *n)
{
char ch;
node=n;
printf("\nWant to create location(y/n):-");
scanf("%c",&ch);
fflush(stdin);
while(ch!='n')
{
fflush(stdin);
node->next=(struct list *)malloc(sizeof(struct list));
node->next->prev=node;
node=node->next;
printf("\Enter value:-");
scanf("%d",&node->num);
fflush(stdin);
printf("\Any more (y/n)");
scanf("%c",&ch);
}
node->next=n;
n->prev=node;
}
void display(struct list *n)
{
node=n->next;
while(node!=n)
{
printf("%d\n",node->num);
node=node->next;
}
}
void main()
{
struct list *start=NULL;
clrscr();
create(start);
printf("Now display the value of the circular lists:-\n");
display(start);
getch();
}
 Lab Practical No. – 12

12. Program of Stack using array

#include <stdio.h>
#define MAX 10 /* The maximum size of the stack */
#include <stdlib.h>

void push(int stack[], int *top, int value)

{
if(*top < MAX )
{
*top = *top + 1;
stack[*top] = value;
}
else
{
printf("The stack is full can not push a value\n");
exit(0);
}
}

void pop(int stack[], int *top, int * value)

{
if(*top >= 0 )
{
*value = stack[*top];
*top = *top - 1;
}
else
{
printf("The stack is empty can not pop a value\n");
exit(0);
}
}

void main()
{
int stack[MAX];
int top = -1;
int n,value;
do
{
do
{
printf("Enter the element to be pushed\n");
scanf("%d",&value);
push(stack,&top,value);
printf("Enter 1 to continue\n");
scanf("%d",&n);
} while(n == 1);

printf("Enter 1 to pop an element\n");

scanf("%d",&n);
while( n == 1)
{
 pop(stack,&top,&value);
printf("The value poped is %d\n",value);
printf("Enter 1 to pop an element\n");
scanf("%d",&n);
}
printf("Enter 1 to continue\n");
scanf("%d",&n);
} while(n == 1);
}

Lab Practical No. – 13

13. Program of Stack using linked list

# include <stdio.h>
# include <stdlib.h>
struct node
{
 int data;
struct node *link;
};

void insert(struct node **front, struct node **rear, int value)

{
struct node *temp;
temp=(struct node *)malloc(sizeof(struct node));
/* creates new node
using data value
passed as parameter */
if(temp==NULL)
{
printf("No Memory available Error\n");
exit(0);
}
temp->data = value;
temp->link=NULL;
if(*rear == NULL)
{
*rear = temp;
*front = *rear;
}
else
{
(*rear)->link = temp;
*rear = temp;
}
}

void delete(struct node **front, struct node **rear, int *value)

{
struct node *temp;
if((*front == *rear) && (*rear == NULL))
{
printf(" The queue is empty cannot delete Error\n");
exit(0);
}
*value = (*front)->data;
temp = *front;
*front = (*front)->link;
if(*rear == temp)
*rear = (*rear)->link;
free(temp);
}

void main()
{
struct node *front=NULL,*rear = NULL;
int n,value;
do
{
do
{
printf("Enter the element to be inserted\n");
scanf("%d",&value);
insert(&front,&rear,value);
printf("Enter 1 to continue\n");
scanf("%d",&n);
} while(n == 1);

printf("Enter 1 to delete an element\n");

scanf("%d",&n);
while( n == 1)
{
delete(&front,&rear,&value);
printf("The value deleted is %d\n",value);
printf("Enter 1 to delete an element\n");
scanf("%d",&n);
}
printf("Enter 1 to continue\n");
scanf("%d",&n);
} while(n == 1);
}

Lab Practical No. – 14

14. Program of Queue

# include <stdio.h>
# include <stdlib.h>
struct node
{
 int data;
int priority;
struct node *link;
};
void insert(struct node **front, struct node **rear, int value,
int priority)
{
struct node *temp,*temp1;
temp=(struct node *)malloc(sizeof(struct node));
/* creates new node using data value
passed as parameter */
if(temp==NULL)
{
printf("No Memory available Error\n");
exit(0);
}
temp->data = value;
temp->priority = priority;
temp->link=NULL;
if(*rear == NULL) /* This is the first node */
{
*rear = temp;
*front = *rear;
}
else
{
if((*front)->priority < priority)
/* the element to be inserted has
highest priority hence should
be the first element*/
{
temp->link = *front;
*front = temp;
}
else
if( (*rear)->priority > priority)
/* the element to be inserted has
lowest priority hence should
be the last element*/
{
(*rear)->link = temp;
*rear = temp;
}

else
{
temp1 = *front;
 while((temp1->link)->priority >= priority)
/* find the position and insert the new element */
temp1=temp1->link;
temp->link = temp1->link;
temp1->link = temp;
}
}
void delete(struct node **front, struct node **rear, int *value,
int *priority)
{
struct node *temp;
if((*front == *rear) && (*rear == NULL))
{
printf(" The queue is empty cannot delete Error\n");
exit(0);
}
*value = (*front)->data;
*priority = (*front)->priority;
temp = *front;
*front = (*front)->link;
if(*rear == temp)
*rear = (*rear)->link;
free(temp);
}

void main()
{
struct node *front=NULL,*rear = NULL;
int n,value, priority;
do
{
do
{
printf("Enter the element to be inserted and its
priority\n");
scanf("%d %d",&value,&priority);
insert(&front,&rear,value,priority);
printf("Enter 1 to continue\n");
scanf("%d",&n);
} while(n == 1);

printf("Enter 1 to delete an element\n");

scanf("%d",&n);
while( n == 1)
{
delete(&front,&rear,&value,&priority);
 printf("The value deleted is %d\ and its priority is
%d \n",
value,priority);
printf("Enter 1 to delete an element\n");
scanf("%d",&n);
}
printf("Enter 1 to delete an element\n");
scanf("%d",&n);
} while( n == 1)
}

Lab Practical No. – 15

15. Program of Circular queue

#include <stdio.h>
#define MAX 10 /* The maximum size of the queue */
#include <stdlib.h>

void insert(int queue[], int *rear, int front, int value)

{
*rear= (*rear +1) % MAX;
if(*rear == front)
{
printf("The queue is full can not insert a value\n");
exit(0);
}
queue[*rear] = value;
}

void delete(int queue[], int *front, int rear, int * value)

{
if(*front == rear)
{
printf("The queue is empty can not delete a value\n");
exit(0);
}
*front = (*front + 1) % MAX;
*value = queue[*front];
}

void main()
{
int queue[MAX];
int front,rear;
int n,value;
front=0; rear=0;
do
{
do
{
printf("Enter the element to be inserted\n");
scanf("%d",&value);
insert(queue,&rear,front,value);
printf("Enter 1 to continue\n");
scanf("%d",&n);
} while(n == 1);

printf("Enter 1 to delete an element\n");

scanf("%d",&n);
while( n == 1)
{
delete(queue,&front,rear,&value);
printf("The value deleted is %d\n",value);
 printf("Enter 1 to delete an element\n");
scanf("%d",&n);
}
printf("Enter 1 to continue\n");
scanf("%d",&n);
} while(n == 1);
}

Lab Practical No. – 16

16. Program of Queue using linked list

# include <stdio.h>
# include <stdlib.h>
struct node
{
int data;
struct node *link;
};

void insert(struct node **front, struct node **rear, int value)

{
struct node *temp;
temp=(struct node *)malloc(sizeof(struct node));
/* creates new node
using data value
passed as parameter */
if(temp==NULL)
{
printf("No Memory available Error\n");
exit(0);
}
temp->data = value;
temp->link=NULL;
if(*rear == NULL)
{
*rear = temp;
*front = *rear;
}
else
{
(*rear)->link = temp;
*rear = temp;
}
}

void delete(struct node **front, struct node **rear, int *value)

{
struct node *temp;
if((*front == *rear) && (*rear == NULL))
{
printf(" The queue is empty cannot delete Error\n");
exit(0);
}
*value = (*front)->data;
temp = *front;
*front = (*front)->link;
if(*rear == temp)
*rear = (*rear)->link;
free(temp);
}
void main()
{
struct node *front=NULL,*rear = NULL;
int n,value;
do
{
do
{
printf("Enter the element to be inserted\n");
scanf("%d",&value);
insert(&front,&rear,value);
printf("Enter 1 to continue\n");
scanf("%d",&n);
} while(n == 1);

printf("Enter 1 to delete an element\n");

scanf("%d",&n);
while( n == 1)
{
delete(&front,&rear,&value);
printf("The value deleted is %d\n",value);
printf("Enter 1 to delete an element\n");
scanf("%d",&n);
}
printf("Enter 1 to continue\n");
scanf("%d",&n);
} while(n == 1);
}

Lab Practical No. – 17

17. Program of Binary Search Tree

#include <stdio.h>
#include <stdlib.h>
struct tnode
{
int data;
struct tnode *lchild, *rchild;
};
int count(struct tnode *p)
{
if( p == NULL)
return(0);
else
if( p->lchild == NULL && p->rchild == NULL)
return(1);
else
return(1 + (count(p->lchild) + count(p-
>rchild)));

struct tnode *insert(struct tnode *p,int val)

{
struct tnode *temp1,*temp2;
if(p == NULL)
{
p = (struct tnode *) malloc(sizeof(struct tnode)); /*
insert the new node as root node*/
if(p == NULL)
{
printf("Cannot allocate\n");
exit(0);
}
p->data = val;
p->lchild=p->rchild=NULL;
}
else
{
temp1 = p;
/* traverse the tree to get a pointer to that node whose
child will be the newly created node*/
while(temp1 != NULL)
{
temp2 = temp1;
if( temp1 ->data > val)
temp1 = temp1->lchild;
else
temp1 = temp1->rchild;
}
if( temp2->data > val)
 {
temp2->lchild = (struct tnode*)malloc(sizeof(struct
tnode)); /
*inserts the newly created node
as left child*/
temp2 = temp2->lchild;
if(temp2 == NULL)
{
printf("Cannot allocate\n");
exit(0);
}
temp2->data = val;
temp2->lchild=temp2->rchild = NULL;
}
else
{
temp2->rchild = (struct tnode*)malloc(sizeof(struct
tnode));/ *inserts the newly created node
as left child*/
temp2 = temp2->rchild;
if(temp2 == NULL)
{
printf("Cannot allocate\n");
exit(0);
}
temp2->data = val;
temp2->lchild=temp2->rchild = NULL;
}
}
return(p);
}
/* a function to binary tree in inorder */
void inorder(struct tnode *p)
{
if(p != NULL)
{
inorder(p->lchild);
printf("%d\t",p->data);
inorder(p->rchild);
}
}
void main()
{
struct tnode *root = NULL;
int n,x;
printf("Enter the number of nodes\n");
scanf("%d",&n);
 while( n --- > 0)
{
printf("Enter the data value\n");
scanf("%d",&x);
root = insert(root,x);
}
inorder(root);
printf("\nThe number of nodes in tree are :
%d\n",count(root));
}

Lab Practical No. – 18

18. Program to convert infix to postfix expression

#include <stdio.h>
#include <string.h>
#include <ctype.h>

#define N 80

typedef enum {FALSE, TRUE} bool;

#include "stack.h"
#include "queue.h"

#define NOPS 7

char operators [] = "()^/*+-";

int priorities[] = {4,4,3,2,2,1,1};
char associates[] = " RLLLL";

char t[N]; char *tptr = t; // this is where prefix will be saved.

int getIndex( char op ) {

/*
* returns index of op in operators.
*/
int i;
for( i=0; i<NOPS; ++i )
if( operators[i] == op )
return i;
return −1;
}

int getPriority( char op ) {

/*
* returns priority of op.
*/
return priorities[ getIndex(op) ];
}

char getAssociativity( char op ) {

/*
* returns associativity of op.
*/
return associates[ getIndex(op) ];
}
void processOp( char op, queue *q, stack *s ) {
/*
* performs processing of op.
*/
switch(op) {
case ')':
 printf( "\t S pushing )...\n" );
sPush( s, op );
break;
case '(':
while( !qEmpty(q) ) {
*tptr++ = qPop(q);
printf( "\tQ popping %c...\n", *(tptr-1) );
}
while( !sEmpty(s) ) {
char popop = sPop(s);
printf( "\tS popping %c...\n", popop );
if( popop == ')' )
break;
*tptr++ = popop;
}
break;
default: {
int priop; // priority of op.
char topop; // operator on stack top.
int pritop; // priority of topop.
char asstop; // associativity of topop.
while( !sEmpty(s) ) {
priop = getPriority(op);
topop = sTop(s);
pritop = getPriority(topop);
asstop = getAssociativity(topop);

if( pritop < priop || (pritop == priop && asstop

== 'L') || topop == ')' ) // IMP.
break;
while( !qEmpty(q) ) {
*tptr++ = qPop(q);
printf( "\tQ popping %c...\n", *(tptr-
1) );
}
*tptr++ = sPop(s);
printf( "\tS popping %c...\n", *(tptr-1) );
}
printf( "\tS pushing %c...\n", op );
sPush( s, op );
break;
}
}
}

bool isop( char op ) {

/*
 * is op an operator?
*/
return (getIndex(op) != −1);
}

char *in2pre( char *str ) {

/*
* returns valid infix expr in str to prefix.
*/
char *sptr;
queue q = {NULL};
stack s = NULL;
char *res = (char *)malloc( N*sizeof(char) );
char *resptr = res;

tptr = t;
for( sptr=str+strlen(str)−1; sptr!=str−1; -sptr ) {
printf( "processing %c tptr-t=%d...\n", *sptr, tptr-t );
if( isalpha(*sptr) ) // if operand.
qPush( &q, *sptr );
else if( isop(*sptr) ) // if valid operator.
processOp( *sptr, &q, &s );
else if( isspace(*sptr) ) // if whitespace.
;
else {
fprintf( stderr, "ERROR:invalid char %c.\n",
*sptr );
return "";

}
}
while( !qEmpty(&q) ) {
*tptr++ = qPop(&q);
printf( "\tQ popping %c...\n", *(tptr-1) );
}
while( !sEmpty(&s) ) {
*tptr++ = sPop(&s);
printf( "\tS popping %c...\n", *(tptr-1) );
}
*tptr = 0;
printf( "t=%s.\n", t );
for( -tptr; tptr!=t−1; -tptr ) {
*resptr++ = *tptr;
}
*resptr = 0;

return res;
}

int main() {
char s[N];

puts( "enter infix freespaces max 80." );

gets(s);
while(*s) {
puts( in2pre(s) );
gets(s);
}

return 0;
}

Lab Practical No. – 19

19. Program of Depth First Search

#include <stdio.h>
#define max 10
/* a function to build adjacency matrix of a graph */
void buildadjm(int adj[][max], int n)
{
int i,j;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{
printf("enter 1 if there is an edge from %d to %d, otherwise
enter
0 \n",
i,j);

scanf("%d",&adj[i][j]);
}
}
/* a function to visit the nodes in a depth-first order */
void dfs(int x,int visited[],int adj[][max],int n)
{
int j;
visited[x] = 1;
printf("The node visited id %d\n",x);
for(j=0;j<n;j++)
if(adj[x][j] ==1 && visited[j] ==0)
dfs(j,visited,adj,n);
}
void main()
{
int adj[max][max],node,n;
int i, visited[max];
printf("enter the number of nodes in graph maximum =
%d\n",max);
scanf("%d",&n);
buildadjm(adj,n);
for(i=0; i<n; i++)
visited[i] =0;
for(i=0; i<n; i++)
if(visited[i] ==0)
dfs(i,visited,adj,n);
}