Record Print Upto Exp6

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


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.


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

{


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 */


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


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/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 your choice 1

Enter the element 8


Enter your choice55 6 8

Enter your choice 1

Enter the element 7


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



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


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.


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.


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


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;

}


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


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

}}

}


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 your choice 1

Enter the element 8


Enter your choice 5

2 4 8

Enter your choice 1

Enter the element 6


Enter your choice 52 4 6 8

Enter your choice 4


Element found at position 2314

Enter your choice 4


Element not found


16/50

Enter your choice 2


Enter your choice 5

2 4 8

Enter your choice 2



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.


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.


18/50

11.Print the resultant polynomial.

SOURCE CODE

#include


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)

{


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;


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;


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


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 exponent0


Create the Second polynomial

Enter no. of terms in the polynomial4

Enter nodes sorted by exponent

Enter the exponent3


Enter the exponent2


Enter the exponent1


Enter the exponent0


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


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


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


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


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


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)

{


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


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.


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.


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 )


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;


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;


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


36/50

if(x!=-1)

printf("\ndeleted element %d ",x);

break;

case 3:

printqueue(q);

break;

case 4:

exit(0);

}

}

}


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 1

Enter the element 8

Full queue- cannot produce further

Enter your choice 2

deleted element 2


Enter your choice 1

Enter the element 8


Enter your choice 2

deleted element 4

Enter your choice 2

deleted element 6

Enter your choice 2


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.

.


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:





40/50

Post-order

Perform the following operations recursively at each 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);

}


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


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.


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,


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.


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)


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

}


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


48/50

break;

case 5:display(t);

break;

case 6:

exit(0);

default :

printf("\n Wrong choice");

}}

}


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 your choice 1

Enter the element 9

Enter your choice 1


Enter your choice 1

Enter the element 8

Enter your choice 1


Enter your choice 1


Enter your choice 1


Enter your choice 1


Enter your choice 58 9 10 11 12 15 17 18 19

Enter your choice 3

minimum element is 8


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


Element not found

Enter your choice 2


Enter your choice 5

9 10 11 12 15 17 18

Enter your choice 2


Enter your choice 5

9 10 11 15 17 18

Enter your choice 6

Record Print Upto Exp6

Documents

Transcript of Record Print Upto Exp6