record print upto exp6
TRANSCRIPT
-
7/27/2019 Record Print Upto Exp6
1/50
1. A. IMPLEMENTATION OF LIST ADT USING SINGLY LINKED LIST
AIM
Write a C Program to implement List ADT operations such as insert, delete,
deletelist, find, and isempty using singly linked list.
ALGORITHM
1. Create a structure named node with a data element and a next pointer of type
structure node
2. Create a header node
a. Dynamically allocate structure size memory.
i. If memory allocation is not successful then return NULL
ii. Else
1. Make that nodes next pointer as NULL.
2. Return the nodes address.
3. Accept the user choice Insert, Delete, DeleteList Find, and Display
4. If the Choice is Insert
a. Get the data and the position(pos) in which the data is to be inserted
b. Move a pointer p from the header node pos times. P points to the node
after which the new node is to be inserted.
c. Create a new node (tempcell) and store the data as tmpcells element.
d. Make p->next as tmpcell->next
e. Make tmpcell as p->next
5. If the Choice is Delete
a. Get the data to be deleted from the list.
b. Find its previous node, and let it be pointed by p.
c. Make p->next as tmpcell
d. Make tmpcell->next as p->next.
e. Free tmpcells memory.
6. If the Choice is DeleteList
a. Move a pointer p through each node until p is not NULL
i. Make p->next as tmp
-
7/27/2019 Record Print Upto Exp6
2/50
ii. Free the node pointed by p
iii. Make tmp as p
7. If the choice is Find
a. Accept the data x
b. Traverse the list till the data x is found or end of list
i. If found display Element found
ii. Else if null reached Element is not found
8. If the choice is Display
a. Display all the elements by traversing the list of nodes using a pointer p
until p becomes NULL.
-
7/27/2019 Record Print Upto Exp6
3/50
SOURCE CODE
#include #include
typedef struct node* ptrtonode;typedef ptrtonode list;
typedef ptrtonode position;typedef int elementtype;
struct node{
elementtype element;ptrtonode next;
};
list createlist(void);
void insert(elementtype x,list l,position p);int islast(position p,list l);int isempty(list l);
void delete1(elementtype x,list l);position find(elementtype x,list l);
position findprevious(elementtype x, list l);void deletelist(list l);
position header(list l);position advance(position p);
elementtype retrieve(position p);
list createlist(void){
list l;l= malloc (sizeof (struct node));
if (l==NULL)
{ printf ("Out of space!");return l;
}
else{ l->next=NULL;
return l;}
}
void insert(elementtype x,list l,position p){
ptrtonode tmpcell;
tmpcell=(list) malloc (sizeof (struct node));if (tmpcell==NULL)
printf ("Out of space\n");else
{
-
7/27/2019 Record Print Upto Exp6
4/50
tmpcell->element=x;tmpcell->next=p->next;
p->next=tmpcell;}
}
int islast(position p,list l)
{return p->next==NULL;
}
int isempty(list l)
{return l->next==NULL;
}
void delete1(elementtype x,list l){
position p,tmpcell;p=findprevious(x,l);
if(!islast(p,l))
{tmpcell=p->next;
p->next=tmpcell->next;free(tmpcell);
}}
position find(elementtype x,list l){position p;
p=l->next;while(p!=NULL && p->element!=x)
p=p->next;
return p;}
position findprevious(elementtype x, list l){
position p;p=l;
while(p->next!=NULL && p->next->element!=x)p=p->next;
return p;}
void deletelist(list l)
{position p,tmp;
p=l->next; /* header assumed */
-
7/27/2019 Record Print Upto Exp6
5/50
l->next=NULL;while(p!=NULL)
{tmp=p->next;
free(p);p=tmp;
}free(l);
}
position header(list l)
{ return l; }
elementtype retrieve(position p){ return p->element; }
position advance(position p)
{ return p->next; }
void printlist(const list l){ position p=header(l);
if(isempty(l))printf("empty list\n");
elsedo
{ p=advance(p);printf("%d\t",retrieve(p));
}while(!islast(p,l));
printf("\n");}
void main(){
int ch,p1,i;
elementtype data;ptrtonode prev,p,pos;
list l;
clrscr();l=createlist();
printf("\n1. Insert an element (Assume header is at position 0)");
printf("\n2. Delete an element");printf("\n3. Delete the list");
printf("\n4. Find an element");printf("\n5. Display List elements");
printf("\n6. Quit");while(1)
{printf("\n Enter your choice ");
scanf("%d",&ch);
-
7/27/2019 Record Print Upto Exp6
6/50
switch(ch)
{case 1:
printf("\n Enter the element ");scanf("%d",&data);
printf("\n Enter the position for insertion ");
scanf("%d",&p1);p=l;
i=1;
while (p->next!=NULL && inext;i++;
}insert(data,l,p);
break;case 2:
printf("\n Enter the element to be Deleted ");scanf("%d",&data);
delete1(data,l);break;
case 3:deletelist(l);
break;case 4:
printf("\n Enter the element to be searched ");scanf("%d",&data);
pos=find(data,l);
if (pos==NULL)printf("\nElement not found");
else
printf("\nElement found at %d",pos);break;
case 5:
printlist(l);break;
case 6:
exit(0);}
}}
-
7/27/2019 Record Print Upto Exp6
7/50
OUTPUT
1. Insert an element
2. Delete an element
3. Delete the list
4. Find an element
5. Display List elements
6. Quit
Enter your choice 1
Enter the element 5
Enter the position for insertion;header is at position 0 1
Enter your choice 1
Enter the element 6
Enter the position for insertion;header is at position 0 2
Enter your choice 1
Enter the element 8
Enter the position for insertion;header is at position 0 3
Enter your choice55 6 8
Enter your choice 1
Enter the element 7
Enter the position for insertion;header is at position 0 3
Enter your choice 5
5 6 7 8
Enter your choice 4
Enter the element to be searched 6
Element found at 2266
Enter your choice 4
Enter the element to be searched 9
-
7/27/2019 Record Print Upto Exp6
8/50
Element not found
Enter your choice 2
Enter the element to be Deleted 7
Enter your choice 55 6 8
Enter your choice 2
Enter the element to be Deleted 8
Enter your choice 55 6
Enter your choice 3
Enter your choice 5
empty list
Enter your choice 6
RESULTThe list ADT is implemented in C language using singly linked list for the operations
insert, delete, find, findprevious, deletelist and isempty and is executed and verified for
sample input.
-
7/27/2019 Record Print Upto Exp6
9/50
1. B. IMPLEMENTATION OF LIST ADT USING DOUBLY LINKED LIST
AIM
Write a C Program to implement List ADT operations such as insert, delete,
deletelist, find, and isempty using doubly linked list.
ALGORITHM
1. Create a structure named node with a data element and two pointers of type
structure node pointing to the previous and next nodes.
2. Create a header node
a. Dynamically allocate structure size memory.
i. If memory allocation is not successful then return NULL
ii. Else
1. Make that nodes prev and next pointer as NULL.
2. Return the nodes address.
3. Accept the user choice Insert, Delete, DeleteList Find, and Display
4. If the Choice is Insert
a. Get the data and the position(pos) in which the data is to be inserted
b. Move a pointer p from the header node pos times. p points to the node
after which the new node is to be inserted.
c. Create a new node(tempcell) and store the data as tmpcells element.
d. Make p->next as tmpcell->next.
e. Make node p as tmpcells previous. and tmpcell as p->next.
f. If tmpcell-> next is not NULL then make tmpcell as the previous of
p->next.
5. If the Choice is Delete
a. Get the data to be deleted from the list.
b. Find that node, and let it be pointed by p.
c. If p is not the last node
i. Make ps next node as the next node of p->prev
ii. Make ps previous node as the previous node of p->next
iii. Free the memory of node p.
-
7/27/2019 Record Print Upto Exp6
10/50
iv. else
1. Make the next of p->prev as NULL.
2. Free the memory of node p.
6. If the Choice is DeleteList
a. Move a pointer p through each node until p is not NULL
i. Make p->next as tmp
ii. Free the node pointed by p
iii. Make tmp as p
7. If the choice is Find
a. Accept the data x
b. Traverse the list till the data x is found or end of list
i. If found display Element found
ii. Else if null reached Element is not found
8. If the choice is Display
a. Display all the elements by traversing the list of nodes using a pointer p
until p becomes NULL.
-
7/27/2019 Record Print Upto Exp6
11/50
SOURCE CODE
#include #include
typedef struct node* ptrtonode;typedef ptrtonode list;
typedef ptrtonode position;typedef int elementtype;
struct node{
elementtype element;ptrtonode next;
ptrtonode prev;};
list createlist(void);void insert(elementtype x,list l,position p);int islast(position p,list l);
int isempty(list l);void delete1(elementtype x,list l);
position find(elementtype x,list l);position findprevious(elementtype x, list l);
void deletelist(list l);position header(list l);
position advance(position p);elementtype retrieve(position p);
list createlist(void)
{list l;
l= malloc (sizeof (struct node));
if (l==NULL){ printf ("Out of space!");
return l;
}else
{ l->next=NULL;l->prev=NULL;
return l;}
}
void insert(elementtype x,list l,position p){
ptrtonode tmpcell,q;
tmpcell=(list) malloc (sizeof (struct node));if (tmpcell==NULL)
printf ("Out of space\n");
-
7/27/2019 Record Print Upto Exp6
12/50
else{
tmpcell->element=x;tmpcell->next=p->next;
tmpcell->prev=p;p->next=tmpcell;
if(tmpcell->next)
p->next->prev=tmpcell;
}
}
int islast(position p,list l){
return p->next==NULL;}
int isempty(list l)
{return l->next==NULL;
}
void delete(elementtype x,list l){
position p,q,r;p=find(x,l);
if(!islast(p,l)){
p->prev->next=p->next;
p->next->prev=p->prev;free(p);
}
else{
p->prev->next=NULL;
free(p);}
}
position find(elementtype x,list l)
{position p;
p=l->next;while(p!=NULL && p->element!=x)
p=p->next;return p;
}
-
7/27/2019 Record Print Upto Exp6
13/50
void deletelist(list l){
position p,tmp;p=l->next; /* header assumed */
l->next=NULL;while(p!=NULL)
{
tmp=p->next;free(p);
p=tmp;
}
free(l);}
position header(list l)
{return l;
}
elementtype retrieve(position p){
return p->element;}
position advance(position p)
{return p->next;
}
void printlist(const list l){ position p=header(l);
if(isempty(l))printf("empty list\n");
else
do{ p=advance(p);
printf("%d\t",retrieve(p));
}while(!islast(p,l));printf("\n");
}
void main(){
int ch,i,p1;elementtype data;
ptrtonode prev,p,pos;list l;
clrscr();l=createlist();
printf("\n1. Insert operation(Assume header is at position 0");
-
7/27/2019 Record Print Upto Exp6
14/50
printf("\n2. Delete an element");printf("\n3. Delete the list");
printf("\n4. Find operation");printf("\n5. Display List elements");
printf("\n6. Quit");
while(1)
{printf("\n Enter your choice ");
scanf("%d",&ch);
switch(ch){
case 1:printf("\n Enter the element ");
scanf("%d",&data);printf("\n Enter the position for insertion ");
scanf("%d",&p1);p=l;
i=1;while (p->next!=NULL && inext;
i++;}
insert(data,l,p);break;
case 2:printf("\n Enter the element to be Deleted ");
scanf("%d",&data);
delete(data,l);break;
case 3:
deletelist(l);break;
case 4:
printf("\n Enter the element to be searched ");scanf("%d",&data);
pos=find(data,l);
if (pos==NULL)printf("\nElement not found");
elseprintf("\nElement found at position %d",pos);
break;case 5:
printlist(l);break;
case 6:exit(0);
}}
}
-
7/27/2019 Record Print Upto Exp6
15/50
OUTPUT
1. Insert operation(Assume header is at position 0)
2. Delete an element3. Delete the list
4. Find operation
5. Display List elements6. Quit
Enter your choice 1
Enter the element 2
Enter the position for insertion 1
Enter your choice 1
Enter the element 4
Enter the position for insertion 2
Enter your choice 1
Enter the element 8
Enter the position for insertion 3
Enter your choice 5
2 4 8
Enter your choice 1
Enter the element 6
Enter the position for insertion 3
Enter your choice 52 4 6 8
Enter your choice 4
Enter the element to be searched 6
Element found at position 2314
Enter your choice 4
Enter the element to be searched 9
Element not found
-
7/27/2019 Record Print Upto Exp6
16/50
Enter your choice 2
Enter the element to be Deleted 6
Enter your choice 5
2 4 8
Enter your choice 2
Enter the element to be Deleted 8
Enter your choice 52 4
Enter your choice 3
Enter your choice 5
empty list
Enter your choice 6
RESULTThe list ADT is implemented in C language using doubly linked list for the operations
insert, delete, find, findprevious, deletelist and isempty and is executed and verified for
sample input.
-
7/27/2019 Record Print Upto Exp6
17/50
2. IMPLEMENTATION OF POLYNOMIAL ADT USING LINKED LIST
AIM
Write a C Program to implement polynomial ADTs addition operation using linked
list implementation of list.
ALGORITHM
1. Define a structure named node with data elements for coefficient & exponent, and a
next pointer of type structure node.
2. Create a header node for the first polynomial.
3. Get the first polynomias coefficients and exponents from the user (give the inputs in
descending order of exponents)
4. For each term of the polynomial, create a node and store the coefficient and power.
5. Link the above nodes to the linked list, for first polynomial.
6. Repeat steps 2 to 5 for the second polynomial.
7. Make 2 pointers to point to first term of both the polynomials.
8. If both the polynomials have terms, do the following
a. If the exponents of both the terms are equal then add the coefficients.
i. Create a node of resultant polynomial
ii. Store the added coefficient and exponent in the node and link it to the
resultant linked list.
iii. Update the pointers to point to next node in each polynomial.
b. If the exponent of first polynomial is greater than the second
i. Then copy the node from the first polynomial to the resultant
polynomial
ii. Update the pointer of the first polynomial to point to next node
c. If the exponent of second polynomial is greater than the first
i. Then copy the node from the second polynomial to the resultant
polynomial
ii. Update the pointer of the second polynomial to point to next node
9. If only the first polynomial has terms then copy the remaining terms of it to the
resultant polynomial.
10. If only end of second polynomial has terms then copy the remaining terms of it to
the resultant polynomial.
-
7/27/2019 Record Print Upto Exp6
18/50
11.Print the resultant polynomial.
SOURCE CODE
#include
-
7/27/2019 Record Print Upto Exp6
19/50
typedef struct node* ptrtonode;
typedef ptrtonode position;typedef ptrtonode polynomial;
struct node
{
int coefficient;int exponent;
ptrtonode next;
};
polynomial createpoly (void);polynomial createheader(void);
void insert(int coeff,int expo,polynomial l,position p);void copypoly(ptrtonode rest,polynomial p3,ptrtonode p3last);
polynomial polyadd(polynomial p1,polynomial p2);position advance(position p);
polynomial createpoly(void){
polynomial l,p;int expo,coeff,no,i;
l=createheader();printf("\n Enter no. of terms in the polynomial");
scanf("%d",&no);p=l;
printf("\nEnter nodes sorted by exponent\n");for(i=1;inext!=NULL)p=p->next;
return p;}
polynomial createheader(void)
{polynomial l;
l=malloc(sizeof(struct node));if (l==NULL)
{
-
7/27/2019 Record Print Upto Exp6
20/50
printf ("Out of space!");return l;
}else
{l->next=NULL;
return l;
}}
void insert(int coeff,int expo,polynomial l,position p){
ptrtonode tmpcell;tmpcell=(ptrtonode)malloc(sizeof(struct node));
if (tmpcell==NULL)printf ("Out of space\n");
else{
tmpcell->coefficient=coeff;tmpcell->exponent=expo;
tmpcell->next=NULL;p->next=tmpcell;
}}
polynomial polyadd(polynomial p1,polynomial p2)
{polynomial l,p;
ptrtonode a1,a2;
int coeff,expo;l=createheader();p=l;
a1=p1->next;a2=p2->next;
while((a1!=NULL) && (a2!=NULL)){
if(a1->exponent==a2->exponent)
{coeff=a1->coefficient+a2->coefficient;
expo=a1->exponent;a1=a1->next;
a2=a2->next;}
else{
if(a1->exponent > a2->exponent){
coeff=a1->coefficient;expo=a1->exponent;
a1=a1->next;
-
7/27/2019 Record Print Upto Exp6
21/50
}else
{ coeff=a2->coefficient;expo=a2->exponent;
a2=a2->next;}
}
p=advance(p);insert(coeff,expo,l,p);
}
while (a1!=NULL)
{p=advance(p);
insert(a1->coefficient ,a1->exponent,l,p);a1=a1->next;
}
while(a2!=NULL){
p=advance(p);insert(a2->coefficient ,a2->exponent,l,p);
a2=a2->next;}
return l;}
void printpoly(polynomial p)
{
p=p->next;while(p->next){
printf( "%dx^%d + ", p->coefficient, p->exponent );p=p->next;
}
if(p->exponent==0){
printf( "%d", p->coefficient);
printf("\n");}
else{
printf( "%dx^%d ", p->coefficient, p->exponent );printf("\n");
}
}
void main(){
polynomial p1,p2,p3;
-
7/27/2019 Record Print Upto Exp6
22/50
clrscr();printf("\n Create the First polynomial\n");
p1=createpoly();printf("\n Create the Second polynomial\n");
p2=createpoly();p3=polyadd(p1,p2);
printf("\nFirst Polynomial= ");
printpoly(p1);printf("\nSecond Polynomial= ");
printpoly(p2);
printf("\nSum of the above two Polynomials= ");printpoly(p3);
}
OUTPUT
Create the First polynomial
-
7/27/2019 Record Print Upto Exp6
23/50
Enter no. of terms in the polynomial3
Enter nodes sorted by exponent
Enter the exponent2
Enter the coefficient5
Enter the exponent1
Enter the coefficient9
Enter the exponent0
Enter the coefficient7
Create the Second polynomial
Enter no. of terms in the polynomial4
Enter nodes sorted by exponent
Enter the exponent3
Enter the coefficient5
Enter the exponent2
Enter the coefficient12
Enter the exponent1
Enter the coefficient7
Enter the exponent0
Enter the coefficient8
First Polynomial= 5x^2 + 9x^1 + 7
Second Polynomial= 5x^3 + 12x^2 + 7x^1 + 8
Sum of the above two Polynomials= 5x^3 + 17x^2 + 16x^1 + 15
-
7/27/2019 Record Print Upto Exp6
24/50
RESULT
The polynomial ADT is implemented in C using linked list to perform polynomial
addition and is executed and verified.
3. CONVERSION OF INFIX EXPRESSION TO POSTFIX EXPRESSION USINGSTACK ADT
-
7/27/2019 Record Print Upto Exp6
25/50
AIM
Write a C program to convert an infix expression to postfix expression using
Stack ADT.
ALGORITHM
1. Get the infix expression to be converted
2. Initialize an empty stack.
3. Scan the Infix expression from left to right one character at a time and repeat
the steps below until null is read.
a. If the scanned character is an operand, add it to the Postfix string.
b. If the scanned character is a left parenthesis ( push it into the stack.
c. If the scanned character is an operator
i. If the stack is empty push it into the stack.
ii. If not empty,
1. Pop all operators having higher precedence over scanned
character and add it to the postfix string.
2. Push the scanned character into the stack.
d. If the scanned character is a right parenthesis )
i. Pop the operators until a left parenthesis is popped and add the
operators to the postfix string.
ii. Discard the left parenthesis.
4. If stack is not empty pop all operators in the stack and add it to the postfix string.
5. Return the Postfix string.
SOURCE CODE
-
7/27/2019 Record Print Upto Exp6
26/50
#include#include "stackadt.c"
int isoperator(char e)
{if(e == '+' || e == '-' || e == '*' || e == '/' || e == '%')
return 1;
elsereturn 0;
}
int priority(char e)
{int pri = 0;
if(e == '*' || e == '/' || e =='%')
pri = 2;else
{if(e == '+' || e == '-')
pri = 1;}
return pri;}
void infix2postfix(char *infix, char *postfix)
{char *i,*p,n1;
stack s;
s=createstack();i = infix;p = postfix;
while(*i)
{
while(*i == ' ' || *i == '\t'){
i++;
}if( isdigit(*i) || isalpha(*i) )
{while( isdigit(*i) || isalpha(*i))
{*p = *i;
p++;i++;
}}
if( *i == '(' ){
push(*i,s);
-
7/27/2019 Record Print Upto Exp6
27/50
i++;}
if( *i == ')')
{n1 = topandpop(s);
while( n1 != '(' )
{*p = n1;
p++;
n1 = topandpop(s);}
i++;}
if( isoperator(*i) ){
if(isempty(s))push(*i,s);
else{
n1 = topandpop(s);while(priority(n1) >= priority(*i))
{*p = n1;
p++;n1 = topandpop(s);
}push(n1,s);
push(*i,s);
}i++;
}
}while(!isempty(s))
{
n1 = topandpop(s);*p = n1;
p++;
}*p = '\0';
}
int main(){
char in[50],post[50];strcpy(post,"");
printf("Enter the Infix Expression : ");fflush(stdin);
gets(in);infix2postfix(in,post);
printf("\nPostfix Expression is : %s\n",post);
-
7/27/2019 Record Print Upto Exp6
28/50
return 0;}
stackadt.c
#include
#include #include
typedef struct stack* stack;
typedef int elementtype;
int MAX=10;#define EMPTYTOS -1
struct stack
{elementtype *array;
int top;int capacity;
};
stack createstack(){
stack s;s=malloc(sizeof(struct stack));
if(s==NULL){
printf("out of space);
return s;}s->array=malloc(sizeof(elementtype)*MAX);
if(s->array==NULL){
printf("out of space);
return s;}
s->capacity=MAX;
s->top=EMPTYTOS;return s;
}void push(elementtype x,stack s)
{if(isfull(s))
printf("\nSTACK FULL");else
s->array[++s->top]=x;}
elementtype topandpop(stack s)
{
-
7/27/2019 Record Print Upto Exp6
29/50
if(isempty(s)){
printf("empty stack\n");return (char)EMPTYTOS;
}else
{
return(s->array[s->top--]);}
}
int isfull(stack s)
{return s->top==MAX-1;
}
int isempty(stack s){
return s->top == EMPTYTOS;}
void emptystack(stack s)
{s->top=EMPTYTOS;
}
OUTPUT
-
7/27/2019 Record Print Upto Exp6
30/50
Enter Infix Expression : a+b*c+(d*e+f)+g
Postfix Expression is : abc*+de*f++g+
Enter Infix Expression : a+b*c+(d*e+f)*g
Postfix Expression is : abc*+de*f+g*+
Enter Infix Expression : ((a+b)*(d-e+f))/(g+h)
Postfix Expression is : ab+de-f+*gh+/
RESULT
Thus the conversion of an infix expression to postfix expression using stack ADT is
implemented in C and is executed and verified.
-
7/27/2019 Record Print Upto Exp6
31/50
4. SIMULATION OF PRODUCER-CONSUMER PROBLEM USING ARRAY
IMPLEMENTAION OF CIRCULAR QUEUE
AIM
Write a C program to simulate producer-consumer problem using array
implementation of circular queue.
ALGORITHM
1. Create a queue structure
a. Let capacity denotes the maximum number of elements in the queue, size
denotes the actual number of elements in the queue and the rear and front
point where insertion and deletion is to be done respectively.
2. Initialize an array of size N
3. If the choice is produce,
a. If the queue is not full.
i. Increment size by one.
ii. Increment the rear pointer, if rear is equal to capacity then wrap
around rear to position 0.
iii. Store the value in rear position.
4. If the choice is consume ,a. If the queue is not empty.
i. Decrement size by one.
ii. Increment the front pointer, if front is equal to capacity then wrap
around front to position 0.
iii. Retrieve the value from front position.
5. If the choice is display, then display the elements of the queue.
-
7/27/2019 Record Print Upto Exp6
32/50
SOURCE CODE
#include
#include
typedef int elementtype;
typedef struct queue *queue;
int isempty( queue q);
int isfull( queue q);
queue createqueue( int maxelements );
void disposequeue( queue q );
void makeempty( queue q );
void enqueue( elementtype x, queue q );
elementtype frontanddequeue( queue q );
struct queue
{
int capacity;
int front;
int rear;
int size;
elementtype *array;
};
int isempty( queue q )
{ return q->size == 0;
}
int isfull( queue q )
{ return q->size == q->capacity;
}
queue createqueue( int maxelements )
-
7/27/2019 Record Print Upto Exp6
33/50
{
queue q;
q = malloc( sizeof( struct queue) );
if( q == NULL )
printf( "Out of space!!!" );
q->array = malloc( sizeof( elementtype ) * maxelements );
if( q->array == NULL )
printf( "Out of space!!!" );
q->capacity = maxelements;
makeempty( q );
return q;
}
void makeempty( queue q )
{
q->size = 0;
q->front = 1;
q->rear = 0;
}
void disposequeue( queue q )
{
if( q != NULL )
{ free( q->array );
free( q );
}
}
void enqueue( elementtype x, queue q )
{ if( isfull( q ) )
{
printf( "\nFull queue- cannot produce further" );
return;
-
7/27/2019 Record Print Upto Exp6
34/50
}
else
{ q->size++;
if (++q->rear==q->capacity)
q->rear=0;
q->array[ q->rear ] = x;
}
getch();
}
elementtype frontanddequeue( queue q )
{
elementtype x = 0;
if( isempty(q))
{
printf("\ncannot consume-empty queue" );
return -1;
}
else
{
q->size--;
x = q->array[ q->front ];
if (++q->front==q->capacity)
q->front=0;
}
return x;
}
void printqueue( queue q)
{
int i,f;
if( isempty( q ) )
printf( "\nqueue is empty" );
else
{ f=q->front;
-
7/27/2019 Record Print Upto Exp6
35/50
for(i=1;isize;i++)
{
printf("\t%d",q->array[f]);
if (++f==q->capacity)
f=0;
}
}
}
void main()
{
queue q;
int x,ch,data;
clrscr();
q = createqueue(3);
printf("Queue size is 3\n");
printf("\n1. Produce ");
printf("\n2. Consume ");
printf("\n3. Display queue elements");
printf("\n4. Quit");
while(1)
{
printf("\n Enter your choice ");
scanf("%d",&ch);
switch(ch)
{
case 1:
printf("\n Enter the element ");
scanf("%d",&data);
enqueue(data,q);
break;
case 2:
x=frontanddequeue(q);
-
7/27/2019 Record Print Upto Exp6
36/50
if(x!=-1)
printf("\ndeleted element %d ",x);
break;
case 3:
printqueue(q);
break;
case 4:
exit(0);
}
}
}
-
7/27/2019 Record Print Upto Exp6
37/50
OUTPUT
Queue size is 3
1. Produce2. Consume
3. Display queue elements
4. QuitEnter your choice 1
Enter the element 2
Enter your choice 1
Enter the element 4
Enter your choice 1
Enter the element 6
Enter your choice 32 4 6
Enter your choice 1
Enter the element 8
Full queue- cannot produce further
Enter your choice 2
deleted element 2
Enter your choice 34 6
Enter your choice 1
Enter the element 8
Enter your choice 34 6 8
Enter your choice 2
deleted element 4
Enter your choice 2
deleted element 6
Enter your choice 2
-
7/27/2019 Record Print Upto Exp6
38/50
deleted element 8
Enter your choice 2
cannot consume-empty queue
Enter your choice 4
RESULT
Thus C program is written to simulate producer-consumer problem using array
implementation of circular queue and is executed ad verified.
.
-
7/27/2019 Record Print Upto Exp6
39/50
5. IMPLEMENTATION OF EXPRESSION TREE ADT AND TREE
TRAVERSALSAIM
Write a program to construct an expression tree and to perform the three different
tree traversals such as in-order traversal, pre-order traversal and post-order traversal.
ALGORITHM
CONSTRUCTON OF EXPRESSION TREE
1. Get the input postfix expression
1. Scan the postfix expression character by character till the end of expression
a) When an operand is encountered
Create a node and store the operand in it
Push its pointer to the stack
b) When an operator is encountered,
Create a node and store the operator in it
Pop two pointers from the stack and make them as child nodes
for the operator (make the first popped pointer the right child
and the other pointer the left child)
Push the operator nodes pointer into the stack
2. The stack will have the pointer of the expression trees root.
TREE TRAVERSAL
Pre-order
Perform the following operations recursively at each node, starting with the root node:
1. Visit the root node.
2. Traverse the left subtree.
3. Traverse the right subtree.
In-order
Perform the following operations recursively at each node:
1. Traverse the left subtree.
2. Visit the root node.
3. Traverse the right subtree.
-
7/27/2019 Record Print Upto Exp6
40/50
Post-order
Perform the following operations recursively at each node:
1. Traverse the left subtree.
2. Traverse the right subtree.
3. Visit the root node.
SOURCE CODE
#include
#include#include
typedef struct tree
{
char data;struct tree *left;struct tree *right;
}*pos;
pos stack[30],temp;int top=-1;
pos newnode(char b){
temp=(struct tree*)malloc(sizeof(struct tree));temp->data=b;
temp->left=NULL;
temp->right=NULL;return(temp);
}
void push(pos temp){
stack[++top]=temp;}
pos pop()
{pos p;
p=stack[top--];return(p);
}
-
7/27/2019 Record Print Upto Exp6
41/50
void inorder(pos t){
if(t!=NULL){
inorder(t->left);printf("%c",t->data);
inorder(t->right);
}}
void preorder(pos t){
if(t!=NULL){
printf("%c",t->data);preorder(t->left);
preorder(t->right);}
}
void postorder(pos t){
if(t!=NULL){
postorder(t->left);postorder(t->right);
printf("%c",t->data);}
}
void main(){
char a[20];pos temp,t;
int j,i;
clrscr();printf("\nEnter the postfix expression ");
gets(a);
for(i=0;a[i]!='\0';i++){
if(a[i]=='*' || a[i]=='/'|| a[i]=='+' || a[i]=='-'){
temp=newnode(a[i]);temp->right=pop();
temp->left=pop();push(temp);
}else
{temp=newnode(a[i]);
push(temp);
-
7/27/2019 Record Print Upto Exp6
42/50
}}
printf(The infix expression is \n);inorder(temp);
printf("\n");printf(The prefix expression is \n);
preorder(temp);
printf("\n");printf(The postfix expression is \n);
postorder(temp);
getch();}
OUTPUT
Enter the postfix expression abc*de+fg//+-
The infix expression is a-b*c+d+e/f/g
The prefix expression is -a+*bc/+de/fg
The postfix expression is abc*de+fg//+-
RESULTThus a C program to construct an expression tree from a postfix expression and to
perform the in-order, pre-order and post-order traversals was written, executed and
verified.
-
7/27/2019 Record Print Upto Exp6
43/50
6. IMPLEMENTATION OF BINARY SEARCH TREE ADT
AIMWrite a C program to implement binary search Tree ADT and perform operations
such as find, findmin, findmax, insert and delete operation on the binary search tree.
ALGORITHM
1. Initialize node structure containing a data element X and two pointers for left
subtree and right subtree.
2. If the choice is Insert,
a. Accept the data element X
b. If the subtree T is null, then create a new treenode T and set
X as Ts element and both Ts left and Ts right as NULL
c. Otherwise if X is less than the data element of treenode T,
recursively traverse left subtree and store X in appropriate place.
d. Otherwise if X is greater than the data element of treenode T, recursively
traverse right subtree and store X in appropriate place.
3. If the choice is delete,
a. Accept the data element to be deleted X.
b. If the X is less than Ts element then set then recursively traverse left and
delete X.
c. Otherwise, check if X is greater than Ts element recursively traverse right
and delete X.
Repeat the steps below for the above steps (b) and (c)
d. If the treenode which is to be deleted has two children, then
Replace the element of treenode T with the smallest data in its
right subtree and recursively delete that smallest element.
e. If the treenode which is to be deleted has one or zero children, then
Return left subtree if the right subtree is null or
Return right subtree if the left subtree is null and
Finally remove the treenode T from the tree
4. If the choice is find,
-
7/27/2019 Record Print Upto Exp6
44/50
a. Accept the Data element X to be found.
b. If X is less than Ts element then continue the search in the left subtree
recursively.
c. Otherwise if X is greater than Ts element then continue the search in the
right subtree recursively.
d. Otherwise return the treenode T
5. If the choice is findmin
a. Recursively traverse the left subtree until Ts left becomes NULL.
b. Return treenode Ts element.
6. If the choice is findmax
a. Recursively traverse the right subtree until Ts right becomes NULL.
b. Return treenode Ts element.
-
7/27/2019 Record Print Upto Exp6
45/50
SOURCE CODE
#include
#include#include
struct treenode;typedef struct treenode *position;
typedef struct treenode *searchtree;typedef int elementtype;
position find(elementtype x,searchtree t);
position findmin(searchtree t);position findmax(searchtree t);
searchtree insert(elementtype x,searchtree t);
searchtree delete1(elementtype x,searchtree t);
struct treenode
{elementtype element;
searchtree left;searchtree right;
};
position find(elementtype x,searchtree t){
if(t==NULL)return NULL;
else if(xelement)return find(x,t->left);
else if(x>t->element)return find(x,t->right);
elsereturn t;
}
position findmin(searchtree t){
if(t==NULL)return NULL;
else if(t->left==NULL)
return t;else
return findmin(t->left);
}
position findmax(searchtree t)
{if(t!=NULL)
-
7/27/2019 Record Print Upto Exp6
46/50
while(t->right!=NULL)t=t->right;
return t;}
searchtree insert(elementtype x,searchtree t)
{
if(t==NULL){ t=malloc(sizeof(struct treenode));
if(t==NULL)
{printf("\n Out of space");
exit(0);}
t->element=x;t->right=t->left=NULL;
}else if(xelement)
t->left=insert(x,t->left);else if(x>t->element)
t->right=insert(x,t->right);return t;
}
void display(searchtree t){
if(t==NULL)return;
display(t->left);
printf("\t%d",t->element);display(t->right);}
searchtree deletion(elementtype x,searchtree t)
{
position tmpcell;if(t==NULL)
{
printf("\nElement not found");return NULL;
}else if(xelement)
t->left=deletion(x,t->left);else if(x>t->element)
t->right=deletion(x,t->right);else if(t->left && t->right)
{tmpcell=findmin(t->right);
t->element=tmpcell->element;t->right=deletion(t->element,t->right);
}
-
7/27/2019 Record Print Upto Exp6
47/50
else{
tmpcell=t;if(t->left==NULL)
t=t->right;else if(t->right==NULL)
t=t->left;
free(tmpcell);}
return t;
}
void main(){
int ch,x;position p;
searchtree t=NULL,min,max;clrscr();
while(1){
printf("\n1.insert\n2.delete\n3.findmin\n4.findmax\n5.display\n6.exit");printf("\nEnter your choice");
scanf("%d",&ch);switch(ch)
{case 1:
printf("\nEnter the element");scanf("%d",&x);
t=insert(x,t);
break;
case 2:
printf("\nEnter the element to be deleted");scanf("%d",&x);
t=deletion(x,t);
break;
case 3:
min=findmin(t);if(min)
printf("\n minimun element is %d",min->element);else
printf("\n Empty tree");break;
case 4:
max=findmax(t);if(max)
printf("\n maximum element is %d",max->element);else
printf("\n Empty tree");
-
7/27/2019 Record Print Upto Exp6
48/50
break;
case 5:display(t);
break;
case 6:
exit(0);
default :
printf("\n Wrong choice");
}}
}
-
7/27/2019 Record Print Upto Exp6
49/50
OUTPUT
1.insert2.delete
3.findmin4.findmax
5.display
6.exitEnter your choice 1
Enter the element 12
Enter your choice 1
Enter the element 17
Enter your choice 1
Enter the element 9
Enter your choice 1
Enter the element 15
Enter your choice 1
Enter the element 8
Enter your choice 1
Enter the element 10
Enter your choice 1
Enter the element 19
Enter your choice 1
Enter the element 18
Enter your choice 1
Enter the element 11
Enter your choice 58 9 10 11 12 15 17 18 19
Enter your choice 3
minimum element is 8
-
7/27/2019 Record Print Upto Exp6
50/50
Enter your choice 4
maximum element is 19
Enter your choice 2
Enter the element to be deleted 8
Enter your choice 5
9 10 11 12 15 17 18 19
Enter your choice 2
Enter the element to be deleted 14
Element not found
Enter your choice 2
Enter the element to be deleted 19
Enter your choice 5
9 10 11 12 15 17 18
Enter your choice 2
Enter the element to be deleted 12
Enter your choice 5
9 10 11 15 17 18
Enter your choice 6