13_ADSALabManual

DEPARTMENT OF COMPUTER SCINCE & ENGINEERING

ADVANCED DATA STRUCTURES & ALGORITHMS LAB

Prepar By

Mr. T.Bhaskar Asst Prof (cse dept)

SREE CHAITANYA INSTITUTE OF TECHNOLOGY & SCIENCES( Affiliated to JNTU,Hyd. & Approved by AICTE New Delhi)

LMD COLONY, THIMMAPOOR KARIM NAGAR PIN: 505527.

Contents

1) Write C++ program to implement the following using an array

a) Stack ADT b) Queue ADT

2) Write C++ programs to implement the following using a singly linked list

a) Stack ADT b) Queue ADT

3) Write C++ program to implement the dequeue (double ended queue) ADT using a doubly

linked list

4) Write a C++ program to perform the following operations:

a) Insert element into a binary search tree.

b) Delete an element from a binary search tree

c) Search for a key element in a binary search tree

5) Write a C++ program to implement circular queue ADT using an array

6) Write a C++ programs that use non-recursive functions to traverse the given binary tree in

a) Preorder b) in order c) post order

7) Write a C++ programs for the implementation of bfs and dfs for a given graph

8) Write C++ programs for implementing that following sorting methods:

Department of CSE ADSA Lab Manual

a) Quick sort b) Merge sort c) Heap sort

9) Write a C++ program to perform the following operations

a) Insertion into a B-tree b) Deletion from B-tree

10) Write a C++ program to perform the following operations

a) Insertion into an AVL tree b) Deletion from an AVL tree

11) Write a C++ program to implement kruskal’s algorithm to generate a minimum spanning tree

12) Write a C++ program for implement prim’s algorithm to generate a minimum spanning tree

13) Write a C++ program to implement all the functions of a dictionary (ADT) using hashing

TABLE OF CONTENTS

S.NOTITLE

(List of programs)PAGE NO

1

2

3

4

5

6

7

8

9

10

a) Stack ADT b) Queue ADT using an array

a) Stack ADT b) Queue ADT using SLL

Dequeue ADT using a doubly linked list

Insert Delete Search operations in binary search

Circular queue ADT using an arraya) Preorder b) in order c) post order

BFS and DFS for a given graph

a) Quick sort b) Merge sort c) Heap sort

a) Insertion into a B-tree b) Deletion from B-treea) Insertion into an AVL tree b) Deletion from an

AVL tree

implement kruskal’s algorithm to generate a

6-12

13-19

20-23

24-30

31-34

35-42

43-48

49-53

54-58

59-69

SCITS, KNR 3


11

12

13

14

minimum spanning tree

Prim’s algorithm to generate a minimum

spanning tree

implement all the functions of a dictionary (ADT)

using hashing

(additional program)

Binary Tree Traversal using Recursion

70-71

72-74

75-81

82-90

C++ Programming Language:

1. The C++ programming language is the advancement to the normal procedure oriented languages like COBOL, FORTRAN, C etc.

2. In case of the object oriented programming (OOP) languages like C++ the data doesn’t flow freely around the system where as it is viewed as a sequence of things such as reading, calculating and printing in case of procedure oriented languages. Data flow freely around the system in this case.

3. The OOP allows decomposition of a problem into number of entities called objects and builds data and functions around the objects. The procedure oriented consists of writing a list of instructions. These instructions grouping into functions.

4. This OOP deals with the real world problems where as procedure oriented doesn’t model real world problems very well.

5. The principles of the OOP are Encapsulation, Data Abstraction, Inheritance, Polymorphism, and Dynamic Binding etc.

Applications of C++:

C++ is a versatile language for handling very large programs. It is suitable for virtually any programming task including development of editors, compilers, databases, communication systems and any complex real-life application systems.

1. Since C++ allows us to create hierarchy-related objects, we can build special object-oriented libraries,

SCITS, KNR 4


which can be used later by many programmers.2. While C++ is able to map the real-world problem

properly, the C part of C++ gives the language the ability to get close to the machine-level details.

3. C++ programs are easily maintainable and expandable. When a new feature needs to be implemented, if is very easy to add to the existing structure of an object.

4. It is expected that C++ will replace C as a general-purpose language in the near future.

C++ Compiler:

1 The file can be stored in C++ like .cpp & .cxx.2. Here we use “CC” command to compile the program like cc.example.c3. The source code available in example.c4. The compiler would produce an object file example.o and then

automatically link with the library functions to produce an executable file.

5. Executable file name is a.out.

C++ Compilation:1. Create and save the source files using under the file options.2. Edit them under the Edit option.3. Compile the program under the compile option and execute it under the

Run option.4. The Run option can be used without compiling the source code. In this

case, the Run command causes the system to compile, link and run the program in one step.

5. A program spread over multiple files can be compiled as cc file1.c file2.0

6. The statement compiles only the file file1.c and links with previously compiled file2.0

7. This is useful when only one of the files needs to be modified. The files that aren’t modified need not be compiled again.

Sample Program:

#include<iostream.h>#include<conio.h>void main() {

SCITS, KNR 5


cout<<” Hello welcome to CPP”;}

Experiment 1:

Problem Statement: Write a C++ Programs to implement the following using an Array

a) Stack ADTb) Queue ADT

a) Solution Design: Design a class named stack which has member variables top, an array s [], ele, ch, I. All member variables have to be global. Design 3 public methods, one to push the elements into the stack; second one to pop from stack and the third is to display the elements in the stack.

Class Name: StackProperties/Member Variables: int top=-1, ele, ch, I, s [];Constructors: None. Public Interface: void push (), pop (), display ();Private Methods: None

Unit Testing Code:Write a main method in the same class above or preferably in a different class that does the following.

SCITS, KNR 6


1. Creates a Stack object. 2. Calls the method push () on the above object and pushes the element

into the stack, calls method pop () to pop the elements out of the stack and the method display () to display the elements from the stack.

3. If the stack is full when pushing, this method prints “Stack overflow”, if stack is empty when popping, this displays “Stack underflow”, and if to display when no elements are present in the stack, this displays that the “stack is empty”.

Test Cases:Test 1:Enter the choice for 1.push 2.pop 3.displayInput: ch=1Expected Output: enter the element to push Input: n=5 Test 2:Input: ch=1Expected Output: enter the element to pushInput: n=3Test 3:Input: ch=3Expected Output: the elements are: 3 5

Test 4:Input: ch=2Expected Output: deleted element is 3

Reference Implementation:####################################################################File: stack.cpp#include<iostream.h>#include<conio.h>#include<process.h>#define max 5int top=-1,s[max],ele,ch,i;template<class t>class stack{public:

void push(void);void pop(void);void display(void);};

template<class t>

SCITS, KNR 7


void stack<t>::push(void){if(top==max-1){cout<<"stack overflows";}else{cout<<"enter the element to push";cin>>ele;top++;s[top]=ele;}}

template<class t>void stack<t>::pop(void){if(top==-1){cout<<"stack underflow";}else{cout<<"deleted element is:"<<s[top]<<endl;top--;}}

template<class t>void stack<t>::display(void){if(top==-1){cout<<"stack is empty";}else{for(i=0;i<=top;i++){cout<<"the elements are:"<<s[top]<<endl;}}}

int main()

SCITS, KNR 8


{clrscr();stack<int>s;while(ch<=3){cout<<"menu\n 1.push 2.pop 3.display 4.exit"<<endl;cin>>ch;switch(ch){case 1:s.push();break;case 2:s.pop();break;case 3:s.display();break;case 4:exit(0);}}getch();return(0);}

####################################################################

Execution: Step 1: Click ‘Alt+F9’ to compile the program.Step 2: Click ‘Ctrl+F9’ to run the program.

Possible Enhancements:The size of the array can be dynamically created instead of creating it statically. Whenever an overflow condition arises instead of displaying the message we can add a method that can create the double size of the array as before to insert the overflowed element.

SCITS, KNR 9


b) Solution Design: Design a class named Queue1 which has r, f, ele, q [max],ch,i as member variables. All member variables have to be global. Design 3 public methods, one to insert the elements into the queue, second to delete the elements from the queue, and the other to display the elements in the queue.

Class Name: Queue1Properties/Member Variables: int r=0, f=0, ele, q [max], ch, iPublic Interface: void insert (), void delete (), void display ()Private Methods: None


1. Create the queue1 object.2. Calls the method insert () to insert the elements into the queue, method

del () to delete the elements from the queue and the method display () to display the elements from the queue.

3. If inserted values exceed the max value of queue It displays “queue overflow”, if to delete from empty queue it displays “queue underflow” and if to display the elements from empty queue it displays “queue is empty”.

Test Cases:Test 1:

SCITS, KNR 10


Enter the choice for 1.insert 2.delete 3.displayInput: ch=1Expected Output: enter the element to insert Input: n=5 Test 2:Input: ch=1Expected Output: enter the element to elementInput: n=3Test 3:Input: ch=3Expected Output: the elements are: 3 5Test 4:Input: ch=2Expected Output: deleted element is 3

Reference Implementation:####################################################################File: queue1.cpp#include<iostream.h>#include<conio.h>#include<process.h>#define max 5int r=0,f=0,ele,q[max],ch,i;template<class t>class queue1{public:

void insert();void del();void display();};

template<class t>void queue1<t>::insert(void){if(r==max){cout<<"queue is overflow"<<endl;

} else{ cout<<”enter the element to insert” cin>>ele;

q[r++]=ele;

SCITS, KNR 11


}}

template<class t>void queue1<t>::del(void){if(f==r){cout<<"queue is underflow"<<endl;}else{cout<<"deleted element is"<<q[f++];}}template<class t>void queue1<t>::display(void){if(f==r){cout<<"queue is empty"<<endl;}else{for(i=f;i<r;i++){cout<<"queue is "<<q[i]<<endl;}}}

int main(){

clrscr();queue1<int>q;while(ch<=3){cout<<"menu 1.insert 2.delet 3.display 4.exit";cin>>ch;switch(ch){case 1:q.insert();

break;case 2:q.del();

SCITS, KNR 12


break;case 3:q.display();

break;}}getch(); return(0);

}

####################################################################


Possible Enhancements:The size of the array can be dynamically created instead of creating it statically. Whenever an overflow condition arises instead of displaying the message we can add a method that can create the double size of the array as before to insert the overflowed element.

Experiment 2:

Problem Statement: Write a C++ Programs to implement the following using an singly linked list

a) Stack ADTb) Queue ADT

a) Solution Design:Design a class Stlink which has a structure node to represent a linked list which is a global. Create 2 links temp, top. All these variables are global. Design 3 public methods, one to push the elements into the stack; second one to pop from stack and the third is to display the elements in the stack.

Class Name: Stlink Properties/Member Variables: temp, topPublic Interface: void push (), pop (), display ().Private Methods: None

SCITS, KNR 13



1. Create a stlink object.2. Calls the method push () on the above object and pushes the element

into the stack, calls method pop () to pop the elements out of the stack and the method display () to display the elements from the stack.

3. If the stack is full when pushing, this method prints “Stack overflow”, if stack is empty when popping, this displays “Stack underflow”, and if to display when no elements are present in the stack, this displays that the “stack is empty”.

Test Cases:Test 1:Enter the choice for 1.push 2.pop 3.displayInput: ch=1Expected Output: enter the element to push Input: n=5 Test 2:Input: ch=1Expected Output: enter the element to pushInput: n=3Test 3:Input: ch=3Expected Output: the elements are: 3 5Test 4:Input: ch=2Expected Output: deleted element is 3

Reference Implementation:File: stlink.cpp

#include<iostream.h>#include<conio.h>struct node{int info;struct node *link;}*p,*temp,*top=NULL;template<class t>class stlink{public:

void push(void);

SCITS, KNR 14


void pop(void);void display(void);};

template<class t>void stlink<t>::push(void){int n;p=new node;cout<<"enter the nodes"<<endl;cin>>n;p->info=n;p->link=top;top=p;}template<class t>void stlink<t>::pop(void){if(top==NULL)cout<<"there are no nodes"<<endl;elsecout<<"deleted element is"<<top->info;top=top->link;}template<class t>void stlink<t>::display(void){if(top==NULL)cout<<"no nodes";else{temp=top;while(temp!=NULL){cout<<"elements are->"<<temp->info;temp=temp->link;}}}int main(){clrscr();stlink<int>s;int ch=0;cout<<"1.push;2.pop;3.display\n";while(ch<=3){

SCITS, KNR 15


cout<<"enter your choice";cin>>ch;switch(ch){case 1:s.push(); break;case 2:s.pop(); break;case 3:s.display(); break;}}getch();return(0);}


Possible Enhancements: As this is created using a linked list the memory can be created dynamically. So, there can be no enhancements further.

b) Solution Design: Design a class queue1 which has structure queue as global. It is used to represent a linked list. The members of this structure are data, next. Create 2 links front, rear. Design 3 public methods, one to insert the elements into the queue, second to delete the elements from the queue, and the other to display the elements in the queue.

Class Name: Queue1Properties/Member Variables: rear, front, nextPublic Interface: void insert (), void del (), void display ()Private Methods: None


SCITS, KNR 16


1. Create the queue1 object.2. Calls the method insert () to insert the elements into the queue, method del () to delete the elements from the queue and the method display () to display the elements from the queue.3. If inserted values exceed the max value of queue It displays “queue overflow”, if to delete from empty queue it displays “queue underflow” and if to display the elements from empty queue it displays “queue is empty”.

Test Cases:Test 1:Enter the choice for 1.insert 2.delete 3.displayInput: ch=1Expected Output: enter the element to insert Input: n=5 Test 2:Input: ch=1Expected Output: enter the element to elementInput: n=3Test 3:Input: ch=3Expected Output: the elements are: 3 5Test 4:Input: ch=2Expected Output: deleted element is 3

Reference Implementation:####################################################################File: QLL.cpp#include<iostream.h>#include<conio.h>#include<process.h>struct queue{int data;struct queue *next;}*p,*rear=NULL,*front=NULL,*temp;template<class t>class queue{public:

SCITS, KNR 17


void insert(void);void del(void);void display(void);};

template<class t>void queue<t>::insert(void){int x;cout<<"enter element to be inserted:";cin>>x;p=new queue;p->data=x;p->next=NULL;if(front==NULL){front=p;rear=p;}else{rear->next=p;rear=p;}}

template<class t>void queue<t>::del(void){if(front==NULL){cout<<"queue underflows\n"<<endl;}else{cout<<"deleted ele is:";cout<front->data;front=front->next;}}

SCITS, KNR 18


template<class t>void queue<t>::display(void){if(front==NULL)cout<<"queue empty";<<endl;else{temp=front;cout<<"ele in the queue are:";while(temp!=NULL){cout<<temp->data;cout<<"->";temp=temp->next;}}}int main(){clrscr();int ch;queue<int>q;do{cout<<"\n menu 1.insert 2.delet 3.display";cout<<"enter choice:";cin>>ch;switch(ch){case 1:q.insert();break;case 2:q.del();break;case 3:q.display();break;case 4:exit(0);}while(ch!=4)}getch();return(0);}

####################################################################


SCITS, KNR 19


Possible Enhancements: As this is created using a linked list the memory can be created dynamically. So, there can be no enhancements further.

Experiment 3: Deque ADT

Problem Statement: Write a C++ programs to implement the Deque (double ended queue) ADT using arrays.

Solution Design: Design a class named Dequeue which has front1, rear1, front2, rear2, size as member variables. All member variables have to be private. Design 6 public methods, one is Dequeue constructor which creates the size of the array dynamically, the other methods are to insert into the queue from the front and another to insert from the rear, the methods to delete the elements from the queue are from the front and from rear ends and the method display () to print the elements from the queue.

SCITS, KNR 20


Class Name: DequeueProperties/Member Variables: int front1, rear1, front2, rear2, size;Constructors: dequeue()Public Interface: void insertf (), insertr (), delf (), delr (), display ();Private Methods: None

Unit Testing Code:Write a main method in the same class above or preferably in a different class that does the following. 1. Create a dequeue object which calls the methods of the class.2. Calls the method insertf() to insert the elements from the front end, and

the method insertr () to insert the elements from the rear end, the methods delf(), delr() to delete the elements the queue from the front and rear ends, and display () method to display the elements in the queue.

3. If the queue is full, then the element when inserted will not be inserted and displays “queue overflow” and when to remove an element from an empty queue it displays “queue underflow”, and for displaying in the same condition will show “queue is empty”.

Test Cases: Enter the choice 0. exit 1. insert front 2. insert rear 3. delete front 4. delete rear 5. displayTest 1:Input: ch=1Expected Output: enter the element to insert Input: n=5 Test 2:Input: ch=2Expected Output: enter the element to elementInput: n=3Test 3:Input: ch=5Expected Output: the elements are: 3 5Test 4:Input: ch=4Expected Output: deleted element is 3

Reference Implementation:####################################################################File: Dequeue.cpp#include<iostream.h>#include<conio.h>

SCITS, KNR 21


template<class t>class dequeue{int front1,rear1,front2,rear2,size;t *a;public:

dequeue();void insertf();void insertr();void delf();void delr();void display();

};template<class t>dequeue<t>::dequeue()

{front1=rear1=0;cout<<"\n enter the size:";cin>>size;a=new t[size];front2=rear2=size-1;

for(int i=0;i<size;i++)a[i]=NULL;

}template<class t>void dequeue<t>::insertf(){if(rear1==size||rear1>rear2)cout<<"\n queue is full";else

{cout<<"\n enter the no:";cin>>a[rear1];rear1++;

}}template<class t>void dequeue<t>::insertr(){if(rear2<rear1||rear2<0)cout<<"\n queue is full";else

{cout<<"\n enter the no:";cin>>a[rear2];rear2--;

SCITS, KNR 22


}}template<class t>void dequeue<t>::delf(){if(front1==size)cout<<"\n queue is empty";else

{int no;cout<<a[front1];a[front1]=NULL;front1++;

}}template<class t>void dequeue<t>::delr(){if(front2<0)cout<<"\n queue is empty";else

{cout<<a[front2];a[front2]=NULL;front2--;

}

}template<class t>void dequeue<t>::display(){if(size==0)cout<<"\n queue is empty";else

{for(int i=0;i<size;i++)

{cout<<a[i]<<" ";

}}

}

void main(){

SCITS, KNR 23


clrscr();dequeue<int> a;int choice;do{cout<<"\n 0-exit,1-insert front,2-insert rear,3-del front,4-del rear,5-display";cin>>choice;switch(choice){case 1:a.insertf();

break;case 2: a.insertr();

break;case 3: a.delf();

break;case 4: a.delr();

break;case 5: a.display();

break;}}while(choice!=0);}

####################################################################


Possible Enhancements: The size of the array can be dynamically created instead of creating it statically. Whenever an overflow condition arises instead of displaying the message we can add a method that can create the double size of the array as before to insert the overflowed element.

Experiment 4: BinarySearchTree operations

Problem Statement:Write a C++ program to perform the following operations:a) Insert an element into a binary search treeb) Delete an element from a binary search treec) Search for a key element in a binary search tree

SCITS, KNR 24


Solution Design: Design a class Node which is used for the linked list declared as friend of class BST, has members data, lchild, rchild. These members are private. Design the actual class BST which has the member variable root of class Node type declared as private. Design 6 methods one for inserting the elements into the BST, next to delete an element from the BST , another to search an element in the BST, the method to display the elements using another method preorder(), the destroy() method to free the nodes created. All the methods need to be declared public.

Class Name: BST Properties/Member Variables: rootPublic Interface: void destroy (Node<T> *p), insert (const T &e), del (const T &k), display (), preorder (Node<T> *p);bool search (const T &k);Constructors: BST ()Private Methods: None

Unit Testing Code: Write a main method in the same class above or preferably in a different class that does the following.

1. Create the BST object.2. Calls the method insert () to insert the elements into the BST, the

method delete () to delete the element from the BST, the method search() to find whether an element is present in the BST or not, the method display () to print the elements in the BST.

3. If the element given for searching is not found, then the method search() displays “element not found”.

Test Cases:Test 1:Enter the choice for 1.insert 2.search 3.delete 4.display 5.exitInput: ch=1Expected Output: enter the element to insert Input: n=5 Test 2:Input: ch=1Expected Output: enter the element to insertInput: n=9Test 3:Input: ch=1Expected Output: enter the element to insertInput: n=3Test 4: Input: ch=4

SCITS, KNR 25


Expected Output: the elements are: 3 9 5Test 5:Input: ch=3Expected Output: enter the element to be deletedInput: n=5Test 6: Input: ch=2 Expected output: enter the element to be searched Input: n=9Expected output: element found

Reference Implementation:#############################################################File: BST.cpp#include<iostream.h>#include<conio.h>#include<process.h>enum bool{false,true};template <class T>class Node{ friend BST<T>; private: T data; Node<T> *lchild,*rchild;};template <class T>class BST{ public: BST()

{ root=NULL;} ~BST(); void destroy(Node<T> *p); bool search(const T &k); void insert(const T &e); void del(const T &k); void display(); void preorder(Node<T> *p); private: Node<T> *root;

};

template<class T>BST<T>::~BST()

SCITS, KNR 26


{ destroy(root);}

template<class T>void BST<T>::destroy(Node<T> *p){ if(p) { destroy(p->lchild); delete p; destroy(p->rchild); }}

template<class T>bool BST<T>::search(const T &k){ Node<T> *p=root; while(p) { if(k<p->data) p=p->lchild; else if(k>p->data) p=p->rchild; else return true; } return false;}template<class T>void BST<T>::insert(const T &e){ Node<T> *p=new Node<T>; Node<T> *temp1=root,*temp2; p->data=e; p->lchild=p->rchild=NULL; if(root==NULL) root=p; else { while(temp1) { temp2=temp1; if(e<temp1->data) temp1=temp1->lchild; else if(e>temp1->data)

SCITS, KNR 27


temp1=temp1->rchild; else{ cout<<"\n element is already there \n";

return; } } if(e>temp2->data) temp2->rchild=p; else temp2->lchild=p; } }

template<class T>void BST<T>::del(const T &k){ Node<T> *p=root; Node<T> *temp=root,*temp2,*s; while(p) { if(k<p->data) { temp=p; p=p->lchild; } else if(k>p->data) { temp=p; p=p->rchild; } else { cout<<p->data<<"is deleted\n"; temp2=p; if(p->lchild) { s=p->lchild; while(s->rchild) { temp2=s; s=s->rchild; } if(temp2!=p) temp2->rchild=s->lchild; else temp2->lchild=s->lchild; }

SCITS, KNR 28


else if(p->rchild) { s=p->rchild; while(s->lchild) { temp2=s; s=s->lchild; } if(temp2!=p) temp2->lchild=s->rchild; else temp2->rchild=s->rchild; } else { s=p; if(p->data>temp->data) temp->lchild=NULL; else temp->lchild=NULL; if(p==root) root=NULL; } p->data=s->data; p=NULL; delete s; return; } } cout<<"\n element not found"; return;}

template<class T>void BST<T>::display(){ if(root) preorder(root); else cout<<"there are no elements in bst\n"; }

template<class T>void BST<T>::preorder(Node<T> *p){ if(p) { cout<<p->data<<"\t";

SCITS, KNR 29


preorder(p->lchild); preorder(p->rchild); }}

void main(){ BST<int> q; int i,ch,x; char t; clrscr(); do { cout<<"\n1.insert 2.search 3.delete 4.display 5.exit"; cout<<"\n enter the choice"; cin>>ch; switch(ch) { case 1: cout<<"\n enter the element to be inserted:";

cin>>x; q.insert(x); break;

case 2: cout<<"\n enter the element to be search"; cin>>x; if(q.search(x)) cout<<x<<"is found"; else cout<<"element not found"; break;

case 3: cout<<"\nenter the element to be deleted"; cin>>x; q.del(x); break;

case 4: q.display(); break;

case 5: exit(0); default: cout<<"\n entered wrong choice"; } cout<<"\n do u want to continue{y/n} :"; cin>>t; }while(t!='n' &&t!='N'); }

####################################################################Execution: Step 1: Click ‘Alt+F9’ to compile the program.

SCITS, KNR 30


Step 2: Click ‘Ctrl+F9’ to run the program.

Experiment 5: Circular Queue ADT

Problem Statement:Write a C++ program to implement circular queue ADT using an array.

Solution Design:

SCITS, KNR 31


Design a class CQ which has a[max], front, rear has its member variables. The member variables front, rear should be public variables, a[max] a private variable. Design 4 member functions where one is a constructor, the other next one is used to insert elements into the circular queue, another to delete the elements from the circular queue, the method display () to print the elements.

Class Name: CQ Properties/Member Variables: a [max], front, rearPublic Interface: void insert (), delete (), display ()Constructors: CQ ()Private Methods: None

Unit Testing Code: Write a main method in the same class above or preferably in a different class that does the following.

1. Create a CQ object.2. Calls the method insert () to enter the elements into the circular queue,

the method delete () to delete the elements from the circular queue, and the method display () to print the elements in the circular queue.

3. If the elements inserted into the circular queue exceed the max size, then if displays “CQ overflow”, similarly if the element is to be deleted from the empty queue it displays “CQ underflow”, and in case of displaying the empty it displays “ CQ empty”.

Test Cases:Enter the choice for 1.insert 2.delete 3.display 4.exitTest 1:Enter the choice for 1.insert 2.delete 3.displayInput: ch=1Expected Output: enter the element to insert Input: n=5 Test 2:Input: ch=1Expected Output: enter the element to elementInput: n=3Test 3:Input: ch=3Expected Output: the elements are: 3 5Test 4:Input: ch=2Expected Output: deleted element is 3

Reference Implementation:##############################################

SCITS, KNR 32


######################File: CQ.cpp#include<iostream.h>#include<conio.h>#include<process.h>#define max 5class CQ{ int a[max]; public: int front, rear; CQ() { rear=front=-1; } void insert(),del(),display();};void CQ::insert(){ if(((rear==max-1)&&(front==0))||(front==rear+1)) cout<<"CQ overflow"; else { int n; cout<<"enter the element to insert"; cin>>n; if(rear!=max-1) { a[++rear]=n; if(front==-1) front++; } else { rear=-1; a[++rear]=n; } } }

void CQ::del() { if(rear==-1) cout<<"cq underflow"; else {

SCITS, KNR 33


cout<<"deleted element is"<<a[front++]; if(front==rear+1) front=rear=-1; if(front==max) front=0; } cout<<endl; }

void CQ::display(){ int i; if(rear==-1) cout<<"cq empty"; else if(front<=rear) for(i=front;i<=rear;i++) cout<<"\t"<<a[i]; else { for(i=front;i<=max-1;i++)

cout<<"\t"<<a[i];for(i=0;i<=rear;i++) cout<<"\t"<<a[i];

} cout<<endl; }

void main() { CQ q; int ch,x; do { cout<<"1.insert 2.delete 3.display 4.exit"; cout<<"enter ur choice"; cin>>ch; switch(ch) { case 1: q.insert();

break; case 2: q.del();

break; case 3:q.display();

break; case 4:exit(0); }

SCITS, KNR 34


} while(ch!=4);}

####################################################################


Possible Enhancements: The size of the array can be created dynamically without giving it statically. Whenever an overflow condition arises instead of displaying the message we can add a method that can create the double size of the array as before to insert the overflowed element.

Experiment 6: Binary Tree Traversal using Non-Recursion

Problem Statement:

SCITS, KNR 35


Write a c++ programs that use non-recursive functions to traverse the given binary treea) Preorder b) Inorder c) Postorder

Solution Design: Design a class Binary Search Tree which has struct tree as a node for representing every element in the tree. This is a private member. Design 6 methods one is a constructor and other to insert the elements into the tree, and there are 3 methods in which the elements can be displayed i.e., the print_preorder (), print_inorder (), print_postorder (). All these are to be declared to be public.Class Name: BinarySearchTree Properties/Member Variables: struct tree_nodePublic Interface: void print_postorder (), print_inorder (), print_preorder (), insert ().Private Methods: void inorder(), preorder(), postorder()


Test Cases: Enter your choice: 1. Insertion/Creation 2. In-Order Traversal 3. Pre-Order Traversal 4. Post-Order Traversal 5. Exit Test 1: Input: ch=1 Expected Output: Enter the element to be inserted Input: n=5 Test 2: Input: ch=1 Expected Output: Enter the element to be inserted Input: n=9 Test 3: Input: ch=1 Expected Output: Enter the element to be inserted Input: n=7 Test 4: Input: ch=2 Expected Output: Inorder-Traversal : 5 9 7 Test 5: Input: ch=3 Expected Output: Preorder-Traversal : 9 5 7 Test 6: Input: ch=4 Expected Output: Postorder-Traversal : 5 7 9

SCITS, KNR 36


Reference Implementation: Using NonRecursive####################################################################File: BinarySearchTree

BINARY TRAVERSALS USING NON RECURSIVE/*Binary search tree with all the Recursive and non Recursive traversals*/

#include<iostream.h>#include<conio.h>#include<stdlib.h>

class binarynode{ public: int data; binarynode *left; binarynode *right;};

class binsrctree{ private: binarynode *root; void inorder(binarynode *); void preorder(binarynode *); void postorder(binarynode *); public: binsrctree() { root=NULL; } void insert(int ); void print_inorder(); void print_preorder(); void print_postorder();};

class stack{ int top;

SCITS, KNR 37


binarynode *stackel[20]; public: stack() { top=-1; } void push(binarynode *); binarynode* pop(); int empty() { if(top==-1) return(1);

return(0); }};

void stack::push(binarynode *node){ stackel[++top]=node;}

binarynode *stack::pop(){ return(stackel[top--]);}

class stack_int{ int top; int stack_int[20]; public: stack_int() { top=-1; } void push(int flag); int pop(); int empty_int() { if(top==-1) return(1);

return(0); }};

SCITS, KNR 38


void stack_int::push(int flag){ stack_int[++top]=flag;}

int stack_int::pop(){ return(stack_int[top--]);}/*---------------------------------------------------------------------*//* FUNCTION TO INSERT A NODE IN THE TREE *//*---------------------------------------------------------------------*/void binsrctree::insert(int val){ binarynode *temp,*prev,*curr; temp=new binarynode; temp->data=val; temp->left=temp->right=NULL;

if(root==NULL) { root=temp; } else { curr=root; while(curr!=NULL) { prev=curr; if(temp->data<curr->data) curr=curr->left; else curr=curr->right; } if(temp->data<prev->data) prev->left=temp; else prev->right=temp; }}

/*--------------------------------------------------*//*INORDER NON RECURSIVE TRAVERSAL*//*--------------------------------------------------*/

SCITS, KNR 39


void binsrctree::inorder(binarynode *root){ stack stk; binarynode *temp; if(root!=NULL) { temp=root; do { while(temp!=NULL) { stk.push(temp); temp=temp->left; }/*end while*/ if(!stk.empty()) { temp=stk.pop(); cout<<temp->data<<" "; temp=temp->right; }/*end if*/ else break; }while(1); /*end do while*/ }/* end if */ else cout<<"Empty tree";

} /*end function */

/*--------------------------------------------------*//*PREORDER NON RECURSIVE TRAVERSAL *//*---------------------------------------------------*/

void binsrctree::preorder(binarynode *root){ stack stk; binarynode *temp=root;

stk.push(temp);

while(!stk.empty()) { temp=stk.pop();

SCITS, KNR 40


if(temp!=NULL) { cout<<temp->data<<" "; stk.push(temp->right); stk.push(temp->left); } }

}

/*--------------------------------------------------*//*POSTORDER NON RECURSIVE TRAVERSAL *//*---------------------------------------------------*/

void binsrctree::postorder(binarynode *root){ stack stk; stack_int stk1; int flag; binarynode *temp=root;

do { if(temp!=NULL) { stk.push(temp); stk1.push(1); temp=temp->left; } else { if(stk.empty()) break; temp=stk.pop(); flag=stk1.pop(); if(flag==2) { cout<<temp->data; temp=NULL; } /*end if */ else { stk.push(temp); stk1.push(2); temp=temp->right;

SCITS, KNR 41


} /* end else */ } /* end if */ }while(1);/*end do while*/}/*end function*/

/*--------------------------------------------------*//*FUNCTION TO PRINT INORDER NON RECURSIVE TRAVERSAL *//*---------------------------------------------------*/

void binsrctree::print_inorder(){ cout<<" "; inorder(root); cout<<" ";}

/*--------------------------------------------------*//*FUNCTION TO PRINT PREORDER NON RECURSIVE TRAVERSAL *//*---------------------------------------------------*/

void binsrctree::print_preorder(){ cout<<" "; preorder(root); cout<<" ";}

/*--------------------------------------------------*//*FUNCTION TO PRINT POSTORDER NON RECURSIVE TRAVERSAL *//*---------------------------------------------------*/

void binsrctree::print_postorder(){ cout<<" "; postorder(root); cout<<" ";}

/*--------------------------------------------------*//* MAIN FUNCTION *//*---------------------------------------------------*/

void main()

SCITS, KNR 42


{ binsrctree BST; int ch,element; clrscr();

do { cout<<"1. Insert a node in binary tree"; cout<<"2. Inorder traversal"; cout<<"3.preorder traversal"; cout<<"4. postorder traversal"; cout<<"5. ”Exit \nEnter your choice"; cin>>ch;

switch(ch) { case 1: cout<<"Enter the element you wnat to insert"; cin>>element; BST.insert(element); break; case 2: cout<<"Inorder traversal"; BST.print_inorder(); break; case 3: cout<<”preorder traversal"; BST.print_preorder(); break; case 4: cout<<"postorder traversal"; BST.print_postorder(); break; case 5:exit(1); } }while(ch!=5);}


SCITS, KNR 43


Experiment 7: Implementation of BFS and DFS

Problem Statement: Write a C++ Programs for implementation of BFS AND DFS for a given graph

Solution Design: Design a main class of the graphs. It contains the 3 methods one to create a graph, and the remaining 2 are for the searches that can be made on the graph i.e., dfs, and bfs. These are declared globally. The struct node, link are the 2 structures that are created to specify the link between the nodes.

Class Name: mainProperties/Member Variables: struct link, node, start, p, q.Constructors: NonePublic Interface: void create (), dfs (), bfs ()Private Methods: None


1. Create a main class which calls the methods create () to form the graph, the method dfs () to traverse the graph in the depth first search order, and the method bfs () to traverse the graph in the breadth first search order.

2. These dfs and bfs methods will display the elements in their respective order.

Test Cases: Graph: 1-2, 1-4, 2-3, 3-5, 3-6, 4-6, 6-7 Enter your choice: 1.BFS 2.DFS 3.Exit.Test 1: Input: ch=1 Expected Output: Breadth First Search: 1-2-3-4-5-6-7Test 2: Input: ch=2 Expected Output: Depth First Search: 1-2-3-5-6-7-4

Reference Implementation:####################################################################File: Graph.cpp

#include<conio.h>#include<iostream.h>#include<stdlib.h>

SCITS, KNR 44


void create(); // For creating a graphvoid dfs(); // For Deapth First Search(DFS) Traversal.void bfs(); // For Breadth First Search(BFS) Traversal.

struct node // Structure for elements in the graph{ int data,status; struct node *next; struct link *adj;};

struct link // Structure for adjacency list{ struct node *next; struct link *adj;};

struct node *start, *p, *q;struct link *l, *k;

int main(){ int choice; clrscr(); create(); do { cout<<"-----------------------"; cout<<"1: DFS 2: BSF 3: Exit \nEnter your choice: "; cin>>choice; switch(choice) {

case 1: dfs(); break; case 2: bfs(); break; case 3: exit(0); break; default: cout<<"Incorrect choice! \nRe-enter your choice."; getch();

} }while(choice!=3); return 0;}

SCITS, KNR 45


void create() // Creating a graph{ int dat,flag=0; start=NULL; cout<<"Enter the nodes in the graph(0 to end): "; while(1) { cin>>dat; if(dat==0)

break; p=new node; p->data=dat; p->status=0; p->next=NULL; p->adj=NULL; if(flag==0) {

start=p; q=p; flag++;

} else {

q->next=p; q=p;

} } p=start; while(p!=NULL) { cout<<"Enter the links to "<<p->data<<" (0 to end) : "; flag=0; while(1) {

cin>>dat; if(dat==0) break; k=new link; k->adj=NULL; if(flag==0) { p->adj=k; l=k; flag++; }

SCITS, KNR 46


else { l->adj=k; l=k; } q=start; while(q!=NULL) { if(q->data==dat) k->next=q; q=q->next; }

} p=p->next; } cout<<"-------------------------"; return;}

// Deapth First Search(DFS) Traversal.void bfs(){ int qu[20],i=1,j=0; p=start; while(p!=NULL) { p->status=0; p=p->next; } p=start; qu[0]=p->data; p->status=1; while(1) { if(qu[j]==0)

break; p=start; while(p!=NULL) {

if(p->data==qu[j]) break; p=p->next;

} k=p->adj; while(k!=NULL)

SCITS, KNR 47


{ q=k->next; if(q->status==0) { qu[i]=q->data; q->status=1; qu[i+1]=0; i++; } k=k->adj;

} j++; } j=0; cout<<"Breadth First Search Results"; cout<<"--------------------------"; while(qu[j]!=0) { cout<<qu[j]<<" "; j++; } getch(); return;}

// Breadth First Search(BFS) Traversal.void dfs(){ int stack[25],top=1; cout<<"Deapth First Search Results"; cout<<"---------------------------"; p=start; while(p!=NULL) { p->status=0; p=p->next; } p=start; stack[0]=0; stack[top]=p->data; p->status=1; while(1) { if(stack[top]==0)

break;

SCITS, KNR 48


p=start; while(p!=NULL) {

if(p->data==stack[top]) break; p=p->next;

} cout<<stack[top]<<" "; top--; k=p->adj; while(k!=NULL) {

q=k->next; if(q->status==0) { top++; stack[top]=q->data; q->status=1; } k=k->adj;

} } getch(); return;}

####################################################################


SCITS, KNR 49


Experiment 8:Implementation of sorting methods

Problem Statement: Write a C++ Programs to implement the following sorting algorithms a) Quick Sort

b) Merge sortc) Heap Sort

Solution Design: Design a class Sort which has the member variable a. This is a private variable.Design 4 methods one for the creation of the list and the other to display the elements in the sorted order by using the heap, merge, and quick sorts. This class contains 2 constructors one for the default allocation of size to the array of elements to be sorted, and the other constructor for dynamic allocation of size for the array.

Class Name: SortProperties/Member Variables: int a;Constructors: Sort (), Sort (int n)Public Interface: void create (), mergesort (), quicksort (), heapsort (), display ()Private Methods: None


1. Create a Sort object, which can call certain methods.2. Calls the methods create () to insert the elements into the array, the

method display () to print the elements in the array in the sorted order using the methods heapsort (), quicksort (), mergesort ().

Test Cases:Test 1:Input: a []= {6,8,3,9,4}Expected Output: using any one of the sorts the sorted order is {3,4,6,8,9}Test 2:Input: a []={15,7,9,34,14}Expected Output: sorted order is: {7,9,14,15,34}

SCITS, KNR 50


Reference Implementation:####################################################################File: sort. cpp#include<iostream.h>#include<conio.h>#include<process.h>template<class T>class sort{private: int a;public: sort(){int a=new int[50];}

sort(int n){int a=new int[n];}void create();void heapsort();

void display();void mergesort();void adjust(int [],int,int);void swap(int a,int b);void print(int [],int);void merge(int [],int,int);};

template<class T>void sort<T>::create(){cout<<"\n Enter the elements";for(int i=0;i<5;i++)cin>>a[i];}

template<class T>void sort<T>::heapsort(){int i,n;cout<<"\n The adjusted List:";for(i=(n-1)/2;i>=0;i--)adjust(a,i,n);for(i=n-1;i>=0;i--){

SCITS, KNR 51


swap(&a[i+1],&a[0]);adjust(a,0,i);}}

template<class T>void sort<T>::adjust(int &a[],int i,int n){int flag=0,j,k;k=a[i];j=2*i+1;while((j<=n)&&!flag){if((j<n)&&a[j]<a[j+1])j++;if(k>=a[j]){flag=1;}else{a[j-1/2]=a[j];j=s*j+1;}}a[(j-1)/2]=k;}

template<class T>

void sort<T>::swap(int *p,int *q){int i;t=*p;*p=*q;*q=*t;}

template<class T>void sort<T>::print(){int i;for(i=0;i<n;i++)cout<<a[i]<<"";}

SCITS, KNR 52


template<class T>void sort<T>::mergesort(){int mid;msort(int a[],int low,int high);}

template<class T>void sort<T>::msort(int a[],int low,int high){int mid;if(low<high){mid=(high+low)/2;msort(a,low,mid);msort(a,mid+1,high);}}

template<class T>void sort<T>::merge(int a[],int &m,int &n){int b[5];int i,j,k;i=1;j=m+1;k=1;while((i<=m)&&(j<=n)){if(a[i]<=a[j])b[k++]=a[i++];elseb[k++]=a[j++];}while(i<=n){b[k++]=a[i++];}while(j<=n)b[k++]=a[j++];for(k=1;k<=n;k++)a[k]=b[k];}

void main(){

SCITS, KNR 53


int c;sort<T> s;do{s.create();cout<<"\n ** Menu **";cout<<"\n 1:Heapsort 2:Mergesort 3:exit";cin>>c;swith(c){case 1: s.heapsort();

break;case 2:s.mergesort();

break;case 3:exit(0);default: cout<<"\n Invalid choice";}}while(c!=4);}

####################################################################


SCITS, KNR 54


Experiment 9: B-Tree Operations

Problem Statement: Write a C++ Programs to perform the following operations

a) Insertion into a B-Treeb) Deletion from a B-Tree

Solution Design: Design a class B_Tree which has the nodes as its member variables. All these variables are private. Design 6 methods one method to create the B-Tree and one method to insert the elements into the tree, one to delete the elements from the tree, another to insert into nonfull tree and to find an element in the tree.

Class Name: B_TreeProperties/Member Variables: int i, n [] Constructors: NonePublic Interface: void insert (), insertNonFull (), delete (), create (), search (), splitChild ().Private Methods: None


1. Create a B_Tree object and calls the methods.2. Calls the method create () to create the initially the

tree, another method insert () the elements into the tree, one method to splitChild when an ordering is required, another method search() to find whether an element is present in the tree or not, one method to delete the elements from the tree.

3. If the element to delete is not found in the tree then it displays “element doesn’t exists”.

Test Cases:

SCITS, KNR 55


Enter tour choice: 1. Create 2. Insert 3. Insertnonfull 4. Search 5. SplitChild 6. Delete 7. Exit”; Test 1: Input: ch=1 Expected Output: enter the element to create: Input: n=8Test 2: Input: ch=2 Expected Output: enter the element to insert: Input: n=5Test 3: Input: ch=2 Expected Output: enter the element to insert: Input: n=7Test 4: Input: ch=6 Expected Output: enter the element to delete: Input: n=8

Reference Implementation:####################################################################File: B-Tree.cpp

#include<iostream.h>#include<conio.h>#include<process.h>class B_Tree{ int i,n[]; public: void search(int,int); void create(T); void splitChild(int,int,int); void insert(int); void insertNonFull(int); void delete(int,int);}

// B-Tree-Search(x, k) void B_Tree::search(int x,int k)

SCITS, KNR 56


{ i <- 1while i <= n[x] and k > keyi[x] do i <- i + 1if i <= n[x] and k = keyi[x] then return (x, i)if leaf[x] then return NIL else Disk-Read(ci[x]) return B-Tree-Search(ci[x], k)

}

// B-Tree-Create(T) void B_Tree::create(T) {

x <- Allocate-Node()leaf[x] <- TRUEn[x] <- 0Disk-Write(x)root[T] <- x

}

// B-Tree-Split-Child(x, i, y) void B_Tree::splitChild(int x,int i,int y) {

z <- Allocate-Node()leaf[z] <- leaf[y]n[z] <- t - 1for j <- 1 to t - 1 do keyj[z] <- keyj+t[y]if not leaf[y] then for j <- 1 to t do cj[z] <- cj+t[y]n[y] <- t - 1for j <- n[x] + 1 downto i + 1 do cj+1[x] <- cj[x]ci+1 <- zfor j <- n[x] downto i do keyj+1[x] <- keyj[x]keyi[x] <- keyt[y]n[x] <- n[x] + 1Disk-Write(y)Disk-Write(z)Disk-Write(x)

}

SCITS, KNR 57


// B-Tree-Insert(T, k) void B_Tree::insert(T,int k) { r <- root[T]

if n[r] = 2t - 1 then s <- Allocate-Node() root[T] <- s

leaf[s] <- FALSE n[s] <- 0 c1 <- r B-Tree-Split-Child(s, 1, r) B-Tree-Insert-Nonfull(s, k)

else B-Tree-Insert-Nonfull(r, k) }

// B-Tree-Insert-Nonfull(x, k) void B_Tree::insertNonFull(int x,int k) {

i <- n[x]if leaf[x] then while i >= 1 and k < keyi[x] do keyi+1[x] <- keyi[x]

i <- i - 1 keyi+1[x] <- k

n[x] <- n[x] + 1 Disk-Write(x)

else while i >= and k < keyi[x] do i <- i - 1

i <- i + 1 Disk-Read(ci[x]) if n[ci[x]] = 2t - 1 then B-Tree-Split-Child(x, i, ci[x]) if k > keyi[x]

then i <- i + 1 B-Tree-Insert-Nonfull(ci[x], k)

} // B-Tree-Delete(x,k) void B_Tree::delete(int x,int k) { If leaf[x]!=NULL && key[x]<-k then leaf[x]=NULL; else cout<<”element not exists”; }

void main()

SCITS, KNR 58


{ int ch,n; B_Tree b; do { cout<<”1.Create 2.Insert 3.Insertnonfull 4.Search 5.SplitChild 6.Delete 7.Exit”; cout<<”Enter your choice:”; cin>>ch; switch(ch) { case 1: cout<<”enter the element to create the B-Tree:”; cin>>n; b.create(x,n); break; case 2: cout<<”enter the element to be inserted”; cin>>n; b.insert(T,n); break; case 3: cout<<”enter the element when the tree is nonfull”; cin>>n; b.insertNonFull(x,n); break; case 4: cout<<”enter the element to be searched:”; cin>>n; b.search(x,n); case 5: b.splitChild(x,i,n); break; case 6: cout<<”enter the element to be deleted”; cin>>n; b.delete(x,n); break; case 7: exit(0); } }while(ch!=7); getch();}

####################################################################


SCITS, KNR 59


Experiment 10: AVL Tree Operations

Problem Statement: Write a C++ Programs to perform the following operations

a) Insertion into an AVL Treeb) Deletion from an AVL Tree

Solution Design: Design a class bstree, which has a structure node with members node left, right and int height which are declared globally. Also a struct node variable nodeptr declared as global. Design methods where one is to insert the elements into the AVL tree, and to find an element in the element, and to display the min and max elements in the tree and to display in the in, pre, and postorder traversals, and methods to delete the min and max values.

Class Name: BstreeProperties/Member Variables: struct node, nodeptr Constructors: NonePublic Interface: void insert (), deletemin (), deletemax (), inorder (), postorder (), preorder (), find (), findmin (),findmax ().Private Methods: None

Unit Testing Code:Write a main method in the same class above or preferably in a different class that does the following. 1. Create a bstree object and call the methods.

2. Calls the method insert () to insert the element in the AVL tree, and 2 methods findmin (), findmax () to find min and max elements in the tree, and find() method to find an element in the tree, copy () method to copy

SCITS, KNR 60


the AVL tree to print in the inorder format, the method delete() to remove the elements from the AVL tree, and the tree traversals are used to display the elements, and height () method to find the levels of the AVL tree.

Test Cases: Enter your choice: 1.Insertion 2.FindMin 3.FindMax 4.Find 5.Copy 6.Delete 7.Preorder 8.Inorder 9.Postorder 10.height Test 1: Input: ch=1 Expected Output: enter the element to be inserted: Input: n=7Test 2: Input: ch=1 Expected Output: enter the element to be inserted: Input: n=4Test 3: Input: ch=1 Expected Output: enter the element to be inserted: Input: n=6Test 4: Input: ch=1 Expected Output: enter the element to be inserted: Input: n=2Test 5: Input: ch=2 Expected Output: the minimum element is: 2Test 6: Input: ch=3 Expected Output: the maximum element is: 7Test 7: Input: ch=6 Expected Output: enter the element to be deleted : 2Test 8: Input: ch=8 Expected Output: the inorder traversal is : 4 6 7

Reference Implementation:####################################################################File: AVLTrees.cpp/* Adelson Velseky Landis Tree */

# include <iostream.h>

SCITS, KNR 61


# include <stdlib.h># include <conio.h>

struct node{ int element; node *left; node *right; int height;};

typedef struct node *nodeptr;

class bstree{

public:void insert(int,nodeptr &);void del(int, nodeptr &);int deletemin(nodeptr &);void find(int,nodeptr &);nodeptr findmin(nodeptr);nodeptr findmax(nodeptr);void copy(nodeptr &,nodeptr &);void makeempty(nodeptr &);nodeptr nodecopy(nodeptr &);void preorder(nodeptr);void inorder(nodeptr);void postorder(nodeptr);int bsheight(nodeptr);nodeptr srl(nodeptr &);nodeptr drl(nodeptr &);nodeptr srr(nodeptr &);nodeptr drr(nodeptr &);int max(int,int);int nonodes(nodeptr);

};

// Inserting a nodevoid bstree::insert(int x,nodeptr &p){ if (p == NULL) {

p = new node;p->element = x;p->left=NULL;

SCITS, KNR 62


p->right = NULL;p->height=0;if (p==NULL)

cout<<"Out of Space"; } else {

if (x<p->element){ insert(x,p->left); if ((bsheight(p->left) - bsheight(p->right))==2) { if (x < p->left->element)

p=srl(p); else

p = drl(p); }}else if (x>p->element){ insert(x,p->right); if ((bsheight(p->right) - bsheight(p->left))==2) {

if (x > p->right->element)p=srr(p);

elsep = drr(p);

}}else

cout<<"Element Exists";}int m,n,d;m=bsheight(p->left);n=bsheight(p->right);d=max(m,n);p->height = d + 1;

}

// Finding the Smallestnodeptr bstree::findmin(nodeptr p){

if (p==NULL){ cout<<"Empty Tree";

SCITS, KNR 63


return p;}else{ while(p->left !=NULL)

p=p->left; return p;}

}

// Finding the Largestnodeptr bstree::findmax(nodeptr p){

if (p==NULL){ cout<<"Empty Tree"; return p;}else{ while(p->right !=NULL) p=p->right; return p;}

}

// Finding an elementvoid bstree::find(int x,nodeptr &p){

if (p==NULL) cout<<"Element not found";elseif (x < p->element) find(x,p->left);elseif (x>p->element) find(x,p->right);else cout<<"Element found !";

}

// Copy a treevoid bstree::copy(nodeptr &p,nodeptr &p1){

makeempty(p1);

SCITS, KNR 64


p1 = nodecopy(p);}

// Make a tree emptyvoid bstree::makeempty(nodeptr &p){

nodeptr d;if (p != NULL){ makeempty(p->left); makeempty(p->right); d=p; free(d); p=NULL;}

}

// Copy the nodesnodeptr bstree::nodecopy(nodeptr &p){

nodeptr temp;if (p==NULL) return p;else{ temp = new node; temp->element = p->element; temp->left = nodecopy(p->left); temp->right = nodecopy(p->right); return temp;}

}

// Deleting a nodevoid bstree::del(int x,nodeptr &p){

nodeptr d;if (p==NULL) cout<<"Element not found";else if ( x < p->element) del(x,p->left);else if (x > p->element) del(x,p->right);else if ((p->left == NULL) && (p->right == NULL)){ d=p;

SCITS, KNR 65


free(d); p=NULL; cout<<" Element deleted !";}else if (p->left == NULL){ d=p; free(d); p=p->right; cout<<" Element deleted !";}else if (p->right == NULL){ d=p; p=p->left; free(d); cout<<" Element deleted !";}else p->element = deletemin(p->right);

}

int bstree::deletemin(nodeptr &p){

int c;cout<<"inside deltemin ";if (p->left == NULL){ c=p->element; p=p->right; return c;}else{ c=deletemin(p->left); return c;}

}

void bstree::preorder(nodeptr p){

if (p!=NULL){ cout<<p->element<<"-->"; preorder(p->left); preorder(p->right);

SCITS, KNR 66


}}

// Inorder Printingvoid bstree::inorder(nodeptr p){

if (p!=NULL){ inorder(p->left); cout<<p->element<<"-->"; inorder(p->right);

}}

// PostOrder Printingvoid bstree::postorder(nodeptr p){ if (p!=NULL) {

postorder(p->left); postorder(p->right); cout<<p->element<<"-->";}

}

int bstree::max(int value1, int value2){

return ((value1 > value2) ? value1 : value2);}

int bstree::bsheight(nodeptr p){

int t;if (p == NULL)

return -1;else{

t = p->height;return t;

}}

nodeptr bstree:: srl(nodeptr &p1){

nodeptr p2;p2 = p1->left;

SCITS, KNR 67


p1->left = p2->right;p2->right = p1;p1->height = max(bsheight(p1->left),bsheight(p1->right)) + 1;p2->height = max(bsheight(p2->left),p1->height) + 1;return p2;

}

nodeptr bstree:: srr(nodeptr &p1){

nodeptr p2;p2 = p1->right;p1->right = p2->left;p2->left = p1;p1->height = max(bsheight(p1->left),bsheight(p1->right)) + 1;p2->height = max(p1->height,bsheight(p2->right)) + 1;return p2;

}

nodeptr bstree:: drl(nodeptr &p1){

p1->left=srr(p1->left);return srl(p1);

}

nodeptr bstree::drr(nodeptr &p1){

p1->right = srl(p1->right);return srr(p1);

}

int bstree::nonodes(nodeptr p){

int count=0;if (p!=NULL){

nonodes(p->left);nonodes(p->right);count++;

}return count;

}

SCITS, KNR 68


int main(){

clrscr();nodeptr root,root1,min,max;//,flag;int a,choice,findele,delele,leftele,rightele,flag;char ch='y';bstree bst;//system("clear");root = NULL;root1=NULL;cout<<"AVL Tree";cout<<"========";do{

cout<<"1.Insertion 2.FindMin 3.FindMax”; cout<<”4.Find 5.Copy 6.Delete 7.Preorder”;

cout<<”8.Inorder 9.Postorder 10.height ";cout<<"Enter the choice:";cin>>choice;switch(choice){case 1: cout<<"New node's value ?";

cin>>a; bst.insert(a,root); break;

case 2: if (root !=NULL){ min=bst.findmin(root); cout<<"Min element :"<<min->element; } break;

case 3: if (root !=NULL) {

max=bst.findmax(root); cout<<"Max element :"<<max->element; } break;

case 4: cout<<"Search node : "; cin>>findele; if (root != NULL)

bst.find(findele,root); break;

case 5: bst.copy(root,root1); bst.inorder(root1);

break;case 6: cout<<"Delete Node ?";

SCITS, KNR 69


cin>>delele; bst.del(delele,root); bst.inorder(root); break;

case 7: cout<<"Preorder Printing... :"; bst.preorder(root); break;

case 8: cout<<" Inorder Printing.... :"; bst.inorder(root); break;

case 9: cout<<" Postorder Printing... :"; bst.postorder(root); break;

case 10: cout<<"Height and Depth is "; cout<<bst.bsheight(root); cout<<"No. of nodes:- "<<bst.nonodes(root); break;

}cout<<"Do u want to continue (y/n) ?";cin>>ch;

}while(ch=='y');

return 0;}

####################################################################


SCITS, KNR 70


Experiment 11: Implementation of Kruskals Algorithm

Problem Statement: Write a C++ Programs to implement Kruskal’s algorithm to generate a minimum spanning tree

Solution Design: Design a class Kruskal which has the members like weight, vertex, edge which are private variables. Design 2 methods one to create the graph, another method to develop the less cost for visiting the entire graph.

Class Name: KruskalProperties/Member Variables: vertex, edge, weightConstructors: NonePublic Interface: void create (), mincost ().Private Methods: None


1. Create an object which calls the methods.2. Calls the method create () to create the graph and the method mincost

() to find the minimum cost for visiting the entire graph.

Test Cases: Creating the graph with their respective weights: 1-(4)-4, 1-(2)-5, 4-(6)-6, 4-(1)-7, 5-(3)-6, 6-(4)-2, 2-(2)-3

SCITS, KNR 71


Test: Input: Mincost Expected Output: the min_cost of the graph using Kruskal’s algorithm is: 17

Reference Implementation:####################################################################File: Kruskal.cpp

Graph& KruskalsAlgorithm (Graph const& g){ unsigned int const n = g.NumberOfVertices ();

Graph& result = *new GraphAsLists (n); for (Vertex::Number v = 0; v < n; ++v)

result.AddVertex (*new Vertex (v));

PriorityQueue& queue = *new BinaryHeap (g.NumberOfEdges ()); Iterator& p = g.Edges (); while (!p.IsDone ()) {

WeightedEdge& edge = dynamic_cast<WeightedEdge&> (*p);Int& weight = dynamic_cast<Int&> (edge.Weight ());queue.Enqueue (*new Assoc (weight, edge));++p;

} delete &p;

Partition& partition = *new PartitionAsForest (n); while (!queue.IsEmpty () && partition.Count () > 1) {

Assoc& assoc = dynamic_cast<Assoc&> (queue.DequeueMin ());Edge& edge = dynamic_cast<Edge&> (assoc.Value ());Vertex::Number const v0 = edge.V0 ();Vertex::Number const v1 = edge.V1 ();Set& s = partition.Find (Set::Element (v0));Set& t = partition.Find (Set::Element (v1));if (s != t){ partition.Join (s, t); result.AddEdge (*new Edge (result[v0], result[v1]));}delete &assoc;

}

SCITS, KNR 72


delete &partition; delete &queue; return result;}

####################################################################


Experiment 12: Implementation of Prim’s Algorithm

Problem Statement: Write a C++ Programs to implement Prim’s algorithm to generate a minimum spanning tree

Solution Design: Design a class Prim’s which has the members like weight, vertex, edge which are private variables. Design 2 methods one to create the graph, another method to develop the less cost for visiting the entire graph.

Class Name: Prim’sProperties/Member Variables: vertex, edge, weightConstructors: NonePublic Interface: void create (), mincost ().Private Methods: None


1. Create an object which calls the methods.2. Calls the method create () to create the graph and the method mincost

() to find the minimum cost for visiting the entire graph.

SCITS, KNR 73


Test Cases: Creating the graph with their respective weights: 1-(4)-4, 1-(2)-5, 4-(6)-6, 4-(1)-7, 5-(3)-6, 6-(4)-2, 2-(2)-3 Test: Input: Mincost Expected Output: the min_cost of the graph using Prim’s algorithm is: 17

Reference Implementation:####################################################################File: Prims.cppGraph& PrimsAlgorithm (Graph const& g, Vertex const& s){ unsigned int const n = g.NumberOfVertices (); Array<TableEntry> table (n); PriorityQueue& queue = *new BinaryHeap (g.NumberOfEdges ()); table [s].distance = 0; queue.Enqueue (*new Assoc (0, const_cast<Vertex&> (s))); while (!queue.IsEmpty ()) {

Assoc& assoc = dynamic_cast<Assoc&> (queue.DequeueMin ());Vertex& v0 = dynamic_cast<Vertex&> (assoc.Value ());if (!table [v0].known){ table [v0].known = true; Iterator& p = g.EmanatingEdges (v0); while (!p.IsDone ()) {

WeightedEdge& edge = dynamic_cast<WeightedEdge&> (*p);Vertex& v1 = edge.Mate (v0);Int& weight = dynamic_cast<Int&> (edge.Weight ());int const d = weight;if (!table[v1].known && table[v1].distance > d){ table [v1].distance = d; table [v1].predecessor = v0; queue.Enqueue (*new Assoc (d, v1));}++p;

} delete &p;}

SCITS, KNR 74


delete &assoc; } delete &queue;

Graph& result = *new GraphAsLists (n); for (Vertex::Number v = 0; v < n; ++v)

result.AddVertex (*new Vertex (v));

for (Vertex::Number v = 0; v < n; ++v)if (v != s) result.AddEdge (*new Edge (

result [v], result [table [v].predecessor])); return result;}

####################################################################


SCITS, KNR 75


Experiment 13: Implementation of Hashing functions

Problem Statement: Write a C++ Programs to implement all the functions of a dictionary (ADT) using hashing.

Solution Design: Design a class Hashtable which has list array which is a private variable.Design 5 methods one is constructor, another is to insert the values into the table, another is to delete the elements from the table, one is to view the element in the hashtable, one is to find an element in the table.

Class Name: HashtableProperties/Member Variables: list table []; Constructors: Hashtable ()Public Interface: void view (), bool insert (), remove (), type find ()Private Methods: None


1. Create a hashtable object which calls the methods.2. Calls the method insert () which inserts the elements into the table, the

method remove () to remove the elements from the table, one method find () is to known whether an element is in the table or not, another

SCITS, KNR 76


method view () is to view the hash table.3. If the element to search is not found in the table it will display “element

not found”.

Test Cases: Enter your choice: 1. Insert 2. Delete 3. Search 4. View 5. Exit Test 1: Input: ch=1 Expected Output: enter the element to insert: Input: n=5Test 2: Input: ch=1 Expected Output: enter the element to insert: Input: n=6Test 3: Input: ch=1 Expected Output: enter the element to insert: Input: n=2Test 4: Input: ch=4 Expected Output: elements in the HashTable are: 5 6 2Test 5: Input: ch=2 Expected Output: enter the element to be deleted: Input: n=6Test 6: Input: ch=2 Expected Output: enter the element to find: Input: n=2 Expected Output: element found

Reference Implementation:####################################################################File: Hashing.cpp

#include<iostream.h>#include<conio.h>#include<process.h>#ifndef _HASHTABLE_H#define _HASHTABLE_H

#include "type.h"#include "list.h"

SCITS, KNR 77


#include "listiter.h"#include <string.h>

#define TABLE_SIZE 33

class Hashtable{

public:Hashtable();bool insert (Type *);void view();Type* find (char*);bool remove(char *);

private:List* table[TABLE_SIZE];int hash (char*); //hash function

};

#endif //_HASHTABLE_H

#include "hashtable.h" #define DEBUG 1

Hashtable::Hashtable(){

for(int i = 0; i < TABLE_SIZE; i++)table[i] = 0;

}

//Hash Function: sum of the ASCII codes of the characters % TABLE_SIZE int Hashtable::hash (char *l){

int long sum = 0;

int len = strlen(l);

for(int i = 0; i < len; i++)sum += l[i];

return sum % TABLE_SIZE;

}

bool Hashtable::insert (Type* new_item)

SCITS, KNR 78


{int index;List* list;Node* p;

index = hash(new_item->get_key());

if(DEBUG) cout<<"\nThe index given by a hashfunction is "<<index;

if(table[index] == 0){table[index] = new List(*new_item);return true;

}else {

list = table[index];p = list->finditem(*new_item);if(p == NULL)

list->insert(*new_item);else

p->setinfo(*new_item);

return true;}

return false; //should never get here}

void Hashtable::view(){

for(int i = 0; i < TABLE_SIZE; i++) {if(table[i] != 0 ){

List list = *table[i];ListIter iter(list);

while(!iter.done()) {if(strcmp(iter.value().get_key(), "*") != 0)

cout << "Index: " << i << iter.value();iter.next();

}}

}}

SCITS, KNR 79


Type* Hashtable::find (char* key){

int index, new_index;Type *item;List *list;Node *p;

item = new Type(key);

new_index = index = hash(key);

if (table[index] == 0)return 0;

list = table[index];

p = list->finditem(*item);

if(p == NULL)return NULL;

else {*item = p->getinfo();return item;

}}

bool Hashtable::remove(char *key){

int index, new_index;List list;

new_index = index = hash(key);

if (table[index] == 0)return false;

list = *table[index];

ListIter iter(list);

while(!iter.done()) {

Node *node = iter.lookup();

Type value = node->getinfo();

SCITS, KNR 80


if (strcmp(value.get_key(), key) == 0) {value.set_key("*");node->setinfo(value);return true;

}

iter.next();}

return false;}

void main(){ Hashtable *table; table = new Hashtable(); int flag = 1;

while(flag) { int choice;

cout << "\n 1. Insert 2. Delete 3. Search 4. View 5. Exit “; cout << "\n Please enter your choice: "; cin >> choice; cin.get();

if(choice == 5) flag = 0; else if(choice == 1)

{ char last_name[20]; char first_name[20]; char key[11]; double gpa; Student *st; bool result;

cout << "\nEnter the key" << endl; cin >> key; cin.get ();

cout << "\nEnter last name" << endl; cin >> last_name; cin.get();

SCITS, KNR 81


cout << "\nEnter first name" << endl; cin >> first_name; cin.get ();

cout << "\nEnter GPA" << endl; cin >> gpa; cin.get();

st = new Type(last_name, first_name, gpa, key); result = table->insert(st);

if(result == true) cout<<endl<<"The record was successfully inserted" << endl;

else cout << endl << "The record was not inserted" << endl;

} else if(choice == 2)

{ char key[20];

bool result;

cout << "\nEnter the key" << endl; cin >> key; cin.get ();

result = table->remove(key); if(result == true)

cout<<"\nThe record was successfully deleted from the table"; else cout << "The record was not found." << endl; } else if(choice == 3) { char key[20]; Student *s; cout << "\nEnter the key" << endl; cin >> key; cin.get ();

s = table->find(key);

if(s) cout << "Found record:" << *s;

else

SCITS, KNR 82


cout << endl << "The record was not found" << endl; } else if(choice == 4) { table->view(); } else cout << "Invalid choice" << endl;};

}

####################################################################


SCITS, KNR 83


ADDITIONAL PROGRAMS

Experiment 14: Binary Tree Traversal using Recursion

Problem Statement:Write a c++ programs that use recursive functions to traverse the given binary treea) Preorder b) Inorder c) Postorder

Solution Design: Design a class Binary Search Tree which has struct tree as a node for representing every element in the tree. This is a private member. Design 6 methods one is a constructor and other to insert the elements into the tree, the other to delete from the tree, and there are 3 methods in which the elements can be displayed i.e., the preorder (), inorder (), postorder (). All these are to be declared to be public.

Class Name: BinarySearchTree Properties/Member Variables: struct tree_nodePublic Interface: void print_postorder (), print_inorder (), print_preorder (), insert (), remove ().

SCITS, KNR 84


Private Methods: None


Test Cases: Enter your choice: 1. Insertion/Creation 2. In-Order Traversal 3. Pre-Order Traversal 4. Post-Order Traversal 5. Removal 6. Exit Test 1: Input: ch=1 Expected Output: Enter the element to be inserted Input: n=5 Test 2: Input: ch=1 Expected Output: Enter the element to be inserted Input: n=9 Test 3: Input: ch=1 Expected Output: Enter the element to be inserted Input: n=7 Test 4: Input: ch=2 Expected Output: Inorder-Traversal : 5 9 7 Test 5: Input: ch=3 Expected Output: Preorder-Traversal : 9 5 7 Test 6: Input: ch=4 Expected Output: Postorder-Traversal : 5 7 9

Reference Implementation: Using Recursive####################################################################File: BinarySearchTree#include <iostream>#include <cstdlib>using namespace std;

class BinarySearchTree{ private: struct tree_node { tree_node* left;

SCITS, KNR 85


tree_node* right; ints data; }; tree_node* root; public: BinarySearchTree() { root = NULL; } bool isEmpty() const { return root==NULL; } void print_inorder(); void inorder(tree_node*); void print_preorder(); void preorder(tree_node*); void print_postorder(); void postorder(tree_node*); void insert(int); void remove(int);};

// Smaller elements go left// larger elements go rightvoid BinarySearchTree::insert(int d){ tree_node* t = new tree_node; tree_node* parent; t->data = d; t->left = NULL; t->right = NULL; parent = NULL; // is this a new tree? if(isEmpty()) root = t; else { //Note: ALL insertions are as leaf nodes tree_node* curr; curr = root; // Find the Node's parent while(curr) { parent = curr; if(t->data > curr->data) curr = curr->right; else curr = curr->left; }

if(t->data < parent->data)

SCITS, KNR 86


parent->left = t; else parent->right = t; }}

void BinarySearchTree::remove(int d){ //Locate the element bool found = false; if(isEmpty()) { cout<<" This Tree is empty! "<<endl; return; } tree_node* curr; tree_node* parent; curr = root; while(curr != NULL) { if(curr->data == d) { found = true; break; } else { parent = curr; if(d>curr->data) curr = curr->right; else curr = curr->left; } } if(!found)

{ cout<<" Data not found! "<<endl; return; }

// 3 cases : // 1. We're removing a leaf node // 2. We're removing a node with a single child // 3. we're removing a node with 2 children

// Node with single child if((curr->left == NULL && curr->right != NULL)|| (curr->left != NULL

SCITS, KNR 87


&& curr->right == NULL)) { if(curr->left == NULL && curr->right != NULL) { if(parent->left == curr) { parent->left = curr->right; delete curr; } else { parent->right = curr->right; delete curr; } } else // left child present, no right child { if(parent->left == curr) { parent->left = curr->left; delete curr; } else { parent->right = curr->left; delete curr; } } return; }

//We're looking at a leaf node if( curr->left == NULL && curr->right == NULL)

{ if(parent->left == curr) parent->left = NULL; else parent->right = NULL;

delete curr; return;

}

//Node with 2 children // replace node with smallest value in right subtree if (curr->left != NULL && curr->right != NULL) { tree_node* chkr;

SCITS, KNR 88


chkr = curr->right; if((chkr->left == NULL) && (chkr->right == NULL)) { curr = chkr; delete chkr; curr->right = NULL; } else // right child has children { //if the node's right child has a left child // Move all the way down left to locate smallest element

if((curr->right)->left != NULL) { tree_node* lcurr; tree_node* lcurrp; lcurrp = curr->right; lcurr = (curr->right)->left; while(lcurr->left != NULL) { lcurrp = lcurr; lcurr = lcurr->left; }

curr->data = lcurr->data; delete lcurr; lcurrp->left = NULL; } else { tree_node* tmp; tmp = curr->right; curr->data = tmp->data;

curr->right = tmp->right; delete tmp; }

} return;

}

}

void BinarySearchTree::print_inorder(){ inorder(root);}

SCITS, KNR 89


void BinarySearchTree::inorder(tree_node* p){ if(p != NULL) { if(p->left) inorder(p->left); cout<<" "<<p->data<<" "; if(p->right) inorder(p->right); } else return;}

void BinarySearchTree::print_preorder(){ preorder(root);}

void BinarySearchTree::preorder(tree_node* p){ if(p != NULL) { cout<<" "<<p->data<<" "; if(p->left) preorder(p->left); if(p->right) preorder(p->right); } else return;}

void BinarySearchTree::print_postorder(){ postorder(root);}

void BinarySearchTree::postorder(tree_node* p){ if(p != NULL) { if(p->left) postorder(p->left); if(p->right) postorder(p->right); cout<<" "<<p->data<<" "; } else return;}

int main(){

SCITS, KNR 90


BinarySearchTree b; int ch,tmp,tmp1; while(1) { cout<<endl<<endl; cout<<" Binary Search Tree Operations "<<endl; cout<<" ----------------------------- "<<endl; cout<<" 1. Insertion/Creation "<<endl; cout<<" 2. In-Order Traversal "<<endl; cout<<" 3. Pre-Order Traversal "<<endl; cout<<" 4. Post-Order Traversal "<<endl; cout<<" 5. Removal "<<endl; cout<<" 6. Exit "<<endl; cout<<" Enter your choice : "; cin>>ch; switch(ch) { case 1 : cout<<" Enter Number to be inserted : "; cin>>tmp; b.insert(tmp); break; case 2 : cout<<endl; cout<<" In-Order Traversal "<<endl; cout<<" -------------------"<<endl; b.print_inorder(); break; case 3 : cout<<endl; cout<<" Pre-Order Traversal "<<endl; cout<<" -------------------"<<endl; b.print_preorder(); break; case 4 : cout<<endl; cout<<" Post-Order Traversal "<<endl; cout<<" --------------------"<<endl; b.print_postorder(); break; case 5 : cout<<" Enter data to be deleted : "; cin>>tmp1; b.remove(tmp1); break; case 6 : system("pause"); return 0; break; } }}

SCITS, KNR 91


####################################################################


SCITS, KNR 92

13_ADSALabManual

Documents

adsa lab manual

programming

binary search

queue adt

quick sort

source code

merge sort

programs