Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
om sakthi
ADHIPARASAKTHI ENGINEERING COLLEGE
MELMARUVATHUR
LAB MANUAL
FOR
DS LAB
CONTENT
EXPERIMENT NAME
EX. NO
PAGE NO.
1A
1B
POLYNOMIAL ADDITION
15
19
22
EXPRESSION TREE
27
31
AVL TREES
37
43
47
10
PRIM'S ALGORITHM
50
11
DIJKSTRAS ALGORITHM
54
12
BUBBLE SORT
58
DS LAB
Algorithm:
1. Start the program
2. Declare all the functions and using the switch case select the operation to be
performed
3. Declare a structure with all the required variables and allocate the memory using the
malloc function
4. In the insert beginning function set y->link=head. For the insert middle check if c<pos
if so set z=x; and x=x->link;and increment c
5.
In the delete beginning function check the above function but perform delete
operation
Program:
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
struct node
{
int data;
struct node *link;
};
struct node *head,*x,*y,*z;
void main()
{
void create();
void insbeg();
void insmid();
void insend();
void delbeg();
3
DS LAB
void delmid();
void delend();
void display();
int ch;
clrscr();
while(1)
{
printf("\n 1.Creation");
printf("\n 2.Insertion at beginning");
printf("\n 3.Insertion at middle");
printf("\n 4.Insertion at end");
printf("\n 5.Deletion at beginning");
printf("\n 6.Deletion at middle");
printf("\n 7.Deletion at end");
printf("\n 8.Display");
printf("\n 9.Exit");
printf("\n Enter ur choice:");
scanf("%d",&ch);
switch(ch)
{
case 1:
create();
break;
case 2:
insbeg();
break;
case 3:
insmid();
break;
case 4:
insend();
break;
case 5:
delbeg();
break;
case 6:
delmid();
break;
case 7:
delend();
break;
case 8:
display();
break;
default:
exit(0);
}
}
}
void create()
4
DS LAB
{
int c;
head=NULL;
x=(struct node*)malloc(sizeof(struct node));
printf("\n Enter the data:");
scanf("%d",&x->data);
x->link=NULL;
head=x;
printf("\n Do u wish to continue press 1 otherwise 0:");
scanf("%d",&c);
while(c!=0)
{
y=(struct node*)malloc(sizeof(struct node));
printf("\n Enter the data:");
scanf("%d",&y->data);
y->link=NULL;
x->link=y;
x=y;
printf("\n Do u wish to continue press 1 otherwise 0:");
scanf("%d",&c);
}
}
void insbeg()
{
y=(struct node*)malloc(sizeof(struct node));
printf("\n Enter the data:");
scanf("%d",&y->data);
y->link=head;
head=y;
}
void insmid()
{
int pos,c=1;
y=(struct node*)malloc(sizeof(struct node));
printf("\n Enter the data:");
scanf("%d",&y->data);
printf("\n Enter the position to be inserted:");
scanf("%d",&pos);
x=head;
while(c<pos)
{
z=x;
x=x->link;
c++;
}
y->link=x;
z->link=y;
}
void insend()
{
5
DS LAB
DS LAB
while(x->link!=NULL)
{
y=x;
x=x->link;
}
y->link=NULL;
free(x);
}
}
void display()
{
if(head==NULL)
printf("\n List is empty");
else
{
x=head;
printf("\n List elements are \n");
while(x->link!=NULL)
{
printf("%d->",x->data);
x=x->link;
}
printf("%d",x->data);
}
}
DS LAB
Output:
DS LAB
Result:
Thus the lists operations are performed using singly linked list in C perform.
Aim:
To a write a C program to implement a doubly linked list
Algorithm:
1. Start the program
2. Declare all the required functions and select the operation to be performed
3. Declare a structure with all the required variables and allocate the memory using the
malloc function
4. Perform insertion, deletion and display operation to insert, delete and display the lists.
5. Stop the program
Program:
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
struct node
{
int data;
struct node *llink;
struct node *rlink;
};
struct node *head,*x,*y,*z;
void main()
{
void create();
void insbeg();
void insmid();
void insend();
void delbeg();
void delmid();
void delend();
void display();
int ch;
clrscr();
while(1)
{
9
DS LAB
printf("\n 1.Creation");
printf("\n 2.Insertion at beginning");
printf("\n 3.Insertion at middle");
printf("\n 4.Insertion at end");
printf("\n 5.Deletion at beginning");
printf("\n 6.Deletion at middle");
printf("\n 7.Deletion at end");
printf("\n 8.Display");
printf("\n 9.Exit");
printf("\n Enter your choice: ");
scanf("%d",&ch);
switch(ch)
{
case 1:
create();
break;
case 2:
insbeg();
break;
case 3:
insmid();
break;
case 4:
insend();
break;
case 5:
delbeg();
break;
case 6:
delmid();
break;
case 7:
delend();
break;
case 8:
display();
break;
default:
exit(0);
}
}
}
void create()
{
int c;
head=NULL;
x=(struct node*)malloc(sizeof(struct node));
printf("\n Enter the data: ");
scanf("%d",&x->data);
x->llink=NULL;
10
DS LAB
x->rlink=NULL;
head=x;
printf("\n Do you wish to continue press 1 or 0:");
scanf("%d",&c);
while(c!=0)
{
y=(struct node*)malloc(sizeof(struct node));
printf("\n Enter the data: ");
scanf("%d",&y->data);
x->rlink=y;
y->llink=x;
y->rlink=NULL;
x=y;
printf("\n Do you wish to continue press 1 or 0:");
scanf("%d",&c);
}
}
void insbeg()
{
y=(struct node*)malloc(sizeof(struct node));
printf("\n Enter the data: ");
scanf("%d",&y->data);
y->llink=NULL;
y->rlink=head;
head->llink=y;
head=y;
}
void insmid()
{
int c=1,pos;
y=(struct node*)malloc(sizeof(struct node));
printf("\n Enter the data: ");
scanf("%d",&y->data);
printf("\n Enter the position to be inserted:");
scanf("%d",&pos);
x=head;
while(c<pos)
{
z=x;
x=x->rlink;
c++;
}
y->rlink=x;
y->llink=z;
x->llink=y;
z->rlink=y;
}
void insend()
{
y=(struct node*)malloc(sizeof(struct node));
11
DS LAB
DS LAB
x=head;
while(x->rlink!=NULL)
{
y=x;
x =x->rlink;
}
y->rlink=NULL;
free(x);
}
}
void display()
{
if(head==NULL)
printf("\n the list is empty");
else
{
x=head;
printf("\nThe list elements are");
while(x->rlink!=NULL)
{
printf("%d->",x->data);
x=x->rlink;
}
printf("%d",x->data);
}
}
13
DS LAB
Output:
14
DS LAB
Result:
Thus the list operations are executed using doubly linked list in C program.
2. POLYNOMIAL ADDITION
Aim:
To write a C program to perform polynomial addition
Algorithm:
1. Start the program
2. Declare all the functions and using the switch case select the operation to be
performed
3. Declare a structure with all the required variables and allocate the memory using the
malloc function
4. Using the while loop check if node->next!=NULL if so print the values of
node->coeff,node->pow
5. Perform the addition according to the conditions of polynomial addition.
6. print the result
7. Stop the program
Program:
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
struct link
{
int coeff;
int pow;
struct link *next;
};
struct link *poly1=NULL,*poly2=NULL,*poly=NULL;
void create(struct link *node)
{
char ch;
do
{
printf("\n enter coeff:");
scanf("%d",&node->coeff);
printf("\n enter power:");
15
DS LAB
scanf("%d",&node->pow);
node->next=(struct link*)malloc(sizeof(struct link));
node=node->next;
node->next=NULL;
printf("\n continue(y/n):");
ch=getch();
}
while(ch=='y' || ch=='Y');
}
void show(struct link *node)
{
while(node->next!=NULL)
{
printf("%dx^%d",node->coeff,node->pow);
node=node->next;
if(node->next!=NULL)
printf("+");
}
}
void polyadd(struct link *poly1,struct link *poly2,struct link *poly)
{
while(poly1->next && poly2->next)
{
if(poly1->pow>poly2->pow)
{
poly->pow=poly1->pow;
poly->coeff=poly1->coeff;
poly1=poly1->next;
}
else if(poly1->pow<poly2->pow)
{
poly->pow=poly2->pow;
poly->coeff=poly2->coeff;
poly2=poly2->next;
}
else
{
poly->pow=poly1->pow;
poly->coeff=poly1->coeff+poly2->coeff;
poly1=poly1->next;
poly2=poly2->next;
}
poly->next=(struct link *)malloc(sizeof(struct link));
poly=poly->next;
poly->next=NULL;
}
while(poly1->next || poly2->next)
{
if(poly1->next)
{
16
DS LAB
poly->pow=poly1->pow;
poly->coeff=poly1->coeff;
poly1=poly1->next;
}
if(poly2->next)
{
poly->pow=poly2->pow;
poly->coeff=poly2->coeff;
poly2=poly2->next;
}
poly->next=(struct link *)malloc(sizeof(struct link));
poly=poly->next;
poly->next=NULL;
}
}
main()
{
char ch;
clrscr();
do{
poly1=(struct link *)malloc(sizeof(struct link));
poly2=(struct link *)malloc(sizeof(struct link));
poly=(struct link *)malloc(sizeof(struct link));
printf("\nenter 1st number:");
create(poly1);
printf("\nenter 2nd number:");
create(poly2);
printf("\n1st Number:");
show(poly1);
printf("\n2nd Number:");
show(poly2);
polyadd(poly1,poly2,poly);
printf("\nAdded polynomial:");
show(poly);
printf("\n add two more numbers:");
ch=getch();
}
while(ch=='y' || ch=='Y');
return 0;
}
17
DS LAB
Output:
Result:
Thus the program for polynomial addition using linked list is executed and verified.
18
DS LAB
DS LAB
if(t==0)
{
if(((str[i]>='a')&&(str[i]<='z'))||(( str[i]>='A')&&(str[i]<='Z')))
stack1[++top1]=str[i];
else
{
if(top2==-1)
stack2[++top2]=str[i];
else
{
if(prec(str[i])>prec(stack2[top2]))
{
stack2[++top2]=str[i];
}
else
{
while(prec(str[i])<=prec(stack2[top2]))
stack1[++top1]=stack2[top2--];
stack2[++top2]=str[i];
}
}
}
}
}
printf("\nANSWER\n");
while(top2>=0)
stack1[++top1]=stack2[top2--];
for(i=0;i<=top1;i++)
printf("%c",stack1[i]);
getch();
}
int prec(char ch)
{
int tt;
if((ch=='+')||(ch=='-'))
tt=2;
if((ch=='*')||(ch=='/'))
tt=3;
if(ch=='(')
tt=1;
return tt;
}
20
DS LAB
Output:
Result:
Thus an infix expression is converted to postfix expression using stack.
21
DS LAB
DS LAB
scanf("%d",&a);
while(a==1)
{
int ch;
printf("\n1.insertion at front");
printf("\n2.deletion at rear ");
printf("\n3.display1");
printf("\n4.exit");
printf("\nenter ur choice");
scanf("%d",&ch);
switch(ch)
{
case 1:
enqfro();
break;
case 2:
deqrea();
break;
case 3:
display1();
break;
default:
exit(0);
}
}
while(a==2)
{
int ch;
printf("\n1.insertion at rear");
printf("\n2.deletion at front");
printf("\n3.display2");
printf("\n4.exit");
printf("\nenter ur choice");
scanf("%d",&ch);
switch(ch)
{
case 1:
enqrea();
break;
case 2:
deqfro();
break;
case 3:
display2();
break;
default:
exit(0);
}
}
}
23
DS LAB
}
void enqfro()
{
if(front==NULL)
{
x=(struct node*)malloc(sizeof(struct node));
printf("\nenter the data");
scanf("%d",&x->data);
x->link=NULL;
rear=x;
front=x;
}
else
{
x=(struct node*)malloc(sizeof(struct node));
printf("\nenter the data");
scanf("%d",&x->data);
x->link=NULL;
front->link=x;
front=x;
}
}
void deqrea()
{
if(rear==NULL)
printf("\nQueue is empty");
else
{
x=rear;
printf("\ndeleted elementis %d",x->data);
rear=x->link;
free(x);
}
}
void enqrea()
{
if(rear==NULL)
{
x=(struct node*)malloc(sizeof(struct node));
printf("\nenter the data");
scanf("%d",&x->data);
x->link=NULL;
rear=x;
front=x;
}
else
{
x=(struct node*)malloc(sizeof(struct node));
printf("\nenter the data");
scanf("%d",&x->data);
24
DS LAB
x->link=NULL;
rear->link=x;
rear=x;
}
}
void deqfro()
{
if(front==NULL)
printf("\nQueue is empty");
else
{
x=front;
printf("\ndeleted elementis %d",x->data);
front=x->link;
free(x);
}
}
void display2()
{
if(front==NULL)
printf("\nqueue is empty");
else
{
x=front;
printf("\nqueue elements are");
while(x->link!=NULL)
{
printf("%d\t",x->data);
x=x->link;
}
printf("%d",x->data);
}
}
void display1()
{
if(rear==NULL)
printf("\nqueue is empty");
else
{
x=rear;
printf("\nqueue elements are");
while(x->link!=NULL)
{
printf("%d\t",x->data);
x=x->link;
}
printf("%d",x->data);
}
}
25
DS LAB
Output:
Result:
Thus the C program to implement the Deque is verified successfully.
26
DS LAB
5. EXPRESSION TREE
Aim:
To construct an expression tree using C program
Algorithm:
1. Start the program
2. Declare all the required functions and select the operation to be performed
3. Allocate the memory location using malloc function
4. In the post function check if p!=NULL if call the recursive function post with
parameters p->rlink and p->llink
5. Using the switch case construct the expression tree
6. Using the push function insert the elements into the tree if topt==max then the tree is
full
7. Print the values
8. Stop the program
Program:
#include<stdio.h>
#include<conio.h>
#include<process.h>
#include<string.h>
#include<stdlib.h>
struct node
{
char c;
struct node *rlink;
struct node *llink;
}*stc[30];
struct node *temp,*root;
char prefix[20],ch;
int topt=-1,max=50,len;
void pusht(struct node *p);
struct node *popt();
void tredis(struct node *ptr,int level);
void exptree();
void post(struct node *p);
void main()
{
clrscr();
printf("Enter a prefix expression:");
scanf("%s",prefix);
//global declaration
27
DS LAB
exptree();
tredis(root,1);
printf("\nThe postfix expression is:");
post(root);
getch();
}
void post(struct node *p)
{
if(p!=NULL)
{
post(p->llink);
post(p->rlink);
printf("%c",p->c);
}
}
void exptree()
{
int i;
len=strlen(prefix);
i=len-1;
while(i>=0)
{
switch(prefix[i])
{
case '+':
case '-':
case '*':
case '/':
case '^':
temp=(struct node*)malloc(sizeof(struct node));
temp->c=prefix[i];
temp->llink=popt();
temp->rlink=popt();
pusht(temp);
break;
default :
temp=(struct node*)malloc(sizeof(struct node));
temp->c=prefix[i];
temp->rlink=NULL;
temp->llink=NULL;
pusht(temp);
}
i--;
}
root=stc[topt];
}
void pusht(struct node * p)
{
if(topt==max)
28
DS LAB
{
printf("/**Beyond Capacity**/");
}
else
{
stc[++topt]=p;
}
}
struct node *popt()
{
if(topt==-1)
printf("/**No Expression**/");
else
return(stc[topt--]);
}
void tredis(struct node *ptr,int level)
{
int i;
if ( ptr!=NULL )
{
tredis(ptr->rlink, level+1);
printf(" ");
for (i = 0; i < level; i++)
printf(" ");
printf("%c", ptr->c);
tredis(ptr->llink, level+1);
}
}
29
DS LAB
Output:
Result:
Thus the C program to construct an expression tree is execute
30
DS LAB
DS LAB
printf("\n1-Insertion");
printf("\n2-Deletion");
printf("\n3-Inorder");
printf("\n4-Exit");
printf("\nEnter Choice:");
scanf("%d",&s);
switch(s)
{
case 1://insertion
if(head==NULL)
{
head=finsert();
}
else
insert(head);
break;
case 2://Deletion
if(head==NULL)
printf("\nBinary Tree Empty.......");
else
{
printf("\nEnter Data to delete:");
scanf("%d",&d);
if(head->llink==NULL && head->rlink==NULL && head->data==d)
{
t=head;
head=NULL;
free(t);
}
else
head = delenode(head,d);
}
break;
case 3://to display
printf("\nIN-ORDER:");
if(head==NULL)
printf("\nBinary Tree Empty....");
else
inorder(head);
break;
case 4://exit
exit(0);
}
}while(s<5 ||s>0);
getch();
}
struct node* finsert()
{
struct node * head;
32
DS LAB
DS LAB
{
if(t->data==d)
{
f=1;
x=t;
break;
}
if(t->data > d)
{
p=t;
t=t->llink;
}
else if(t->data <= d)
{
p=t;
t=t->rlink;
}
}
if(f==0)
{
printf("\nGiven element not found.......");
return head;
}
//Deleted node has no child
if(x->llink==NULL && x->rlink==NULL)
{
if(p->rlink==x)
p->rlink=NULL;
else
p->llink=NULL;
free(x);
return head;
}
//deleted node has 2 children
if(x->llink!=NULL && x->rlink!=NULL)
{
p=x;
t1=x->rlink;
while(t1->llink!=NULL)
{
p=t1; f1=1;
t1=t1->llink;
}
if(t1->llink==NULL && t1->rlink==NULL)
{
x->data=t1->data;
if(f1==1)
p->llink=t1->llink;
if(f1==0)
x->rlink=t1->rlink;
34
DS LAB
free(t1);
return head;
}
if(t1->rlink!=NULL)
{
x->data=t1->data;
if(f1==1)
p->llink=t1->rlink;
if(f1==0)
p->rlink=t1->rlink;
free(t1);
return head;
}
}
//Deleted node has oniy right child
if(x->llink==NULL && x->rlink!=NULL && x->data!=head->data)
{
if(p->llink==x)
p->llink=x->rlink;
else
p->rlink=x->rlink;
free(x);
return head;
}
//Deleted node has oniy left child
if(x->llink!=NULL && x->rlink==NULL && x->data!=head->data)
{
if(p->llink==x)
p->llink=x->llink;
else
p->rlink=x->llink;
free(x);
return head;
}
if(x->llink!=NULL && x->rlink==NULL && x->data==head->data)
{
head=x->llink;
free(p);
return head;
}
if(x->llink==NULL && x->rlink!=NULL && x->data==head->data)
{
head=x->rlink;
free(p);
return head;
}
return 0;
}
35
DS LAB
Output:
Result:
Thus the binary search tree is constructed and various operations are performed using
C program.
36
DS LAB
7. AVL TREE
Aim:
To write a C program to perform insertion on an AVL tree
Algorithm:
1. Start the program
2. Declare all the functions and using the switch case select the operation to be
performed
3. Declare a structure with all the required variables and allocate the memory using the
malloc function
4. Check if (search (root, info) == NULL ), if so assign the value to the variable root
5. Insert an element into the tree.
6. After insertion check if the tree is balanced or not. If not balance the tree.
7. Stop the program.
Program:
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
typedef enum { FALSE ,TRUE } bool;
struct node
{
int info;
int balance;
struct node *lchild;
struct node *rchild;
};
struct node *insert (int , struct node *, int *);
struct node* search(struct node *,int);
main()
{
bool ht_inc;
int info ;
int choice;
struct node *root = (struct node *)malloc(sizeof(struct node));
root = NULL;
clrscr();
while(1)
{
printf("1.Insert\n");
37
DS LAB
printf("2.Display\n");
printf("3.Quit\n");
printf("Enter your choice : ");
scanf("%d",&choice);
switch(choice)
{
case 1:
printf("Enter the value to be inserted : ");
scanf("%d", &info);
if( search(root,info) == NULL )
root = insert(info, root, &ht_inc);
else
printf("Duplicate value ignored\n");
break;
case 2:
if(root==NULL)
{
printf("Tree is empty\n");
continue;
}
printf("Tree is :\n");
display(root, 1);
printf("\n\n");
printf("Inorder Traversal is: ");
inorder(root);
printf("\n");
break;
case 3:
exit(1);
default:
printf("Wrong choice\n");
}/*End of switch*/
}/*End of while*/
}/*End of main()*/
struct node* search(struct node *ptr,int info)
{
if(ptr!=NULL)
if(info < ptr->info)
ptr=search(ptr->lchild,info);
else if( info > ptr->info)
ptr=search(ptr->rchild,info);
return(ptr);
}/*End of search()*/
struct node *insert (int info, struct node *pptr, int *ht_inc)
{
struct node *aptr;
struct node *bptr;
if(pptr==NULL)
{
pptr = (struct node *) malloc(sizeof(struct node));
38
DS LAB
pptr->info = info;
pptr->lchild = NULL;
pptr->rchild = NULL;
pptr->balance = 0;
*ht_inc = TRUE;
return (pptr);
}
if(info < pptr->info)
{
pptr->lchild = insert(info, pptr->lchild, ht_inc);
if(*ht_inc==TRUE)
{
switch(pptr->balance)
{
case -1: /* Right heavy */
pptr->balance = 0;
*ht_inc = FALSE;
break;
case 0: /* Balanced */
pptr->balance = 1;
break;
case 1: /* Left heavy */
aptr = pptr->lchild;
if(aptr->balance == 1)
{
printf("Left to Left Rotation\n");
pptr->lchild= aptr->rchild;
aptr->rchild = pptr;
pptr->balance = 0;
aptr->balance=0;
pptr = aptr;
}
else
{
printf("Left to right rotation\n");
bptr = aptr->rchild;
aptr->rchild = bptr->lchild;
bptr->lchild = aptr;
pptr->lchild = bptr->rchild;
bptr->rchild = pptr;
if(bptr->balance == 1 )
pptr->balance = -1;
else
pptr->balance = 0;
if(bptr->balance == -1)
aptr->balance = 1;
else
aptr->balance = 0;
bptr->balance=0;
pptr=bptr;
39
DS LAB
}
*ht_inc = FALSE;
}/*End of switch */
}/*End of if */
}/*End of if*/
if(info > pptr->info)
{
pptr->rchild = insert(info, pptr->rchild, ht_inc);
if(*ht_inc==TRUE)
{
switch(pptr->balance)
{
case 1: /* Left heavy */
pptr->balance = 0;
*ht_inc = FALSE;
break;
case 0: /* Balanced */
pptr->balance = -1;
break;
case -1: /* Right heavy */
aptr = pptr->rchild;
if(aptr->balance == -1)
{
printf("Right to Right Rotation\n");
pptr->rchild= aptr->lchild;
aptr->lchild = pptr;
pptr->balance = 0;
aptr->balance=0;
pptr = aptr;
}
else
{
printf("Right to Left Rotation\n");
bptr = aptr->lchild;
aptr->lchild = bptr->rchild;
bptr->rchild = aptr;
pptr->rchild = bptr->lchild;
bptr->lchild = pptr;
if(bptr->balance == -1)
pptr->balance = 1;
else
pptr->balance = 0;
if(bptr->balance == 1)
aptr->balance = -1;
else
aptr->balance = 0;
bptr->balance=0;
pptr = bptr;
}/*End of else*/
*ht_inc = FALSE;
40
DS LAB
}/*End of switch */
}/*End of if*/
}/*End of if*/
return(pptr);
}/*End of insert()*/
display(struct node *ptr,int level)
{
int i;
if ( ptr!=NULL )
{
display(ptr->rchild, level+1);
printf("\n");
for (i = 0; i < level; i++)
printf(" ");
printf("%d", ptr->info);
display(ptr->lchild, level+1);
}/*End of if*/
}/*End of display()*/
inorder(struct node *ptr)
{
if(ptr!=NULL)
{
inorder(ptr->lchild);
printf("%d ",ptr->info);
inorder(ptr->rchild);
}
}/*End of inorder()*/
41
DS LAB
Output:
Result:
Thus the C program to perform insertion on an AVL tree is executed and verified
42
DS LAB
8. PRIORITY QUEUE USING BINARY HEAPS
Aim:
To write a C program to perform Priority queue using binary heaps.
Algorithm:
1. Start the program
2. Declare all the functions and the operation to be performed
3. Declare a structure with all the required variables and define the Max Size of packet
4. Exchange to maintain heap property
5. Find the correct place to insert the element
6. After insertion check if the tree is balanced or not
7. Stop the program.
Program:
#include <stdio.h>
#define MAX_SIZE 10
typedef struct
{
unsigned char priority;
unsigned char packetType;
unsigned int destinationAddress;
unsigned int sourceAddress;
char payload[26];
} Packet;
typedef struct
{
Packet* packets[MAX_SIZE];
unsigned int size;
} PacketHeap;
void heap_init(PacketHeap* h)
{
h->size=0;
}
void heap_heapify(PacketHeap* h,int i)
{
int l,r,smallest;
Packet* tmp;
l=2*i; /*left child*/
43
DS LAB
44
DS LAB
int main()
{
PacketHeap heap;
unsigned char i;
Packet p[10];
p[0].priority=123;
p[1].priority=23;
p[2].priority=0;
p[3].priority=22;
p[4].priority=255;
p[5].priority=1;
p[6].priority=10;
p[7].priority=3;
p[8].priority=101;
p[9].priority=102;
clrscr();
heap_init(&heap);
for (i=0;i<10;i++)
{
printf("Add %i\n",p[i].priority);
heap_addItem(&heap,&(p[i]));
}
while (!heap_isEmpty(&heap))
{
i=heap_extractMin(&heap)->priority;
printf("%i\n",i);
}
getch();
return 0;
}
45
DS LAB
Output:
Result:
Thus the C program to perform Priority queue using binary heaps is executed and
verified
46
DS LAB
Program:
#include<STDIO.H>
#include<conio.h>
void main()
{
int a[10]={0,0,0,0,0,0,0,0,0,0};
int n,value,temp,hashvalue;
clrscr();
printf("\nEnter the value of n(table size):");
scanf("%d",&n);
do
{
printf("\nEnter the hash value");
scanf("%d",&value);
hashvalue=value%n;
if(a[hashvalue]==0)
{
a[hashvalue]=value;
printf("\na[%d]the value %d is stored",hashvalue,value);
}
else
{
for(hashvalue++;hashvalue<n;hashvalue++)
{
if(a[hashvalue]==0)
{
printf("Space is allocated give other value");
a[hashvalue]=value;
printf("\n a[%d]the value %d is stored",hashvalue,value);
goto menu;
}
47
DS LAB
}
hashvalue=0;
for(hashvalue;hashvalue<n;hashvalue++)
{
if(a[hashvalue]==0)
{
printf("Space is allocated give other value");
a[hashvalue]=value;
printf("\n a[%d]the value %d is stored",hashvalue,value);
goto menu;
}
}
printf("ERROR");
printf("\nEnter '0' and press 'Enter key' twice to exit");
}
menu:
printf("\n Do u want enter more ENTER 1 here:");
scanf("%d",&temp);
}
while(temp==1);
getch();
}
48
DS LAB
Output:
Result:
Thus the C program to perform Hashing with open addressing is executed and
verified.
49
DS LAB
Program:
#include<stdio.h>
#include<conio.h>
int b[10][10],a[10][10],v,v1,v2,n,e,visited[10],edge,cost,i,j;
void initialize()
{
printf("\nEnter the number of nodes\n");
scanf("%d",&n);
printf("\Enter the number of edges\n");
scanf("%d",&e);
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
a[i][j]=0;
for(i=1;i<=n;i++)
visited[i]=0;
for(i=1;i<=e;i++)
{
printf("\nEnter the two vertices v1 & v2 \n");
scanf("%d%d",&v1,&v2);
printf("\nEnter the corresponding cost\n");
scanf("%d",&edge);
a[v1][v2]=edge;
}
}
int prim()
{
for(i=1;i<=n;i++)
50
DS LAB
for(j=1;j<=n;j++)
if(i==j)
b[i][j]=0;
else
b[i][j]=999;
for(i=1;i<=n-1;i++)
{
findmin(&v1,&v2);
edge=a[v1][v2];
b[v1][v2]=b[v2][v1]=edge;
visited[v1]=visited[v2]=1;
cost=cost+edge;
}
return cost;
}
int findmin(int *v1,int *v2)
{
int edge=0,i;
for(i=1;i<=n;i++)
{
for(j=i+1;j<=n;j++)
{
if((visited[i]==1&&visited[j]!=1)||(visited[i]!=1&&visited[j]==1))
{
if((edge>a[i][j]||edge==0)&&a[i][j]>0)
{
edge=a[i][j];
*v1=i;
*v2=j;
}
}
}
}
return;
}
void main()
{
int val;
clrscr();
initialize();
val=prim();
printf("\nThe cost is %d\n",val);
printf("\nThe matrix is\n");
for(i=1;i<=n;i++)
{
51
DS LAB
for(j=1;j<=n;j++)
{
printf("%d\t",b[i][j]);
}
printf("\n");
}
getch();
}
52
DS LAB
Output:
Result:
Thus the C program to find MST of an undirected graph using Prims algorithm is
executed and verified
53