Oops and Ds Lab1

www.VidyarthiPlus.in Data Structures and Object Oriented Programming Lab

Compiled by P.Irin Saji, Lecturer/CSE © Copyright 2011-15 1

Document Name : Data Structure and OOPS Lab Manual

Thanks to :

P.Irin Saji,

Lecturer/CSE

www.Vidyarthiplus.in

Facebook: www.facebook.com/VidyarthiPlus

Twitter: www.twitter.com/vidyarthiplus


Compiled by P.Irin Saji, Lecturer/CSE 2

Ex.No:1(a) STUDENT RECORD (Class and Object)

Aim:

To write a program in C++ to prepare a student Record using class and object.

Algorithm:

1. Create a class record.

2. Read the name, Regno ,mark1,mark2,mark3 of the student. 3. Calculate the average of mark as Avg=mark1+mark2+mark3/3 4. Display the student record. 5. Stop the program.

Program:

#include<iostream.h> #include<conio.h> class record { public: char name[20]; int regno; int marks,m1,m2,m3; float avg; void getdata() { cout<<"\nenter the name: " ; cin>>name; cout<<"enter the regno: "; cin>>regno; cout<<"enter the m1,m2,m3: \n"; cin>>m1>>m2>>m3; } void calculate() { avg=(m1+m2+m3)/3; } void display() { cout<<"******************\n"; cout<<"\nName: "<<name; cout<<"\nRegno: "<<regno; cout<<"\nMark1: "<<m1; cout<<"\nMark2: "<<m2; cout<<"\nMark3: "<<m3; cout<<"\nAvg: "<<avg; cout<<"******************\n"; } };



void main() { record r; clrscr(); r.getdata(); r.calculate(); r.display(); getch(); } Output: Enter the name: Avanthika Enter the reg no: 1 Enter the m1,m2,m3: 90,90,90 Name: Avantika Regno: 1 Mark1: 90 Mark2: 90 Mark3: 90 Average:90 Result:

Thus the C++ program for implementation of classes and objects was created, executed and output was verified successfully.



Ex.No:1(b) UNARY OPERATOR OVERLOADING

Aim: To write a C++ program for implementing the unary operator overloading. Algorithm:

1. Start the process.

2. Invoke the class counter.

3. Crate two objects c1 and c2 and assign values to them.

4. Call c1.get_count() and then Call c2.get_count()

5. Increment the values C1++ , C2++ and ++c2

6. Print c1 and c2.

7. Stop the process

Program:

#include<iostream.h> #include<conio.h> class counter { int count; public: counter() { count=0; } int get_count() { return count; } void operator++() { count++; } }; void main() { counter c1,c2; cout<<"\nC1 ="<<c1.get_count(); cout<<"\nC2 ="<<c2.get_count(); c1++; //Using overloaded ++ operator. c2++; ++c2; cout<<"\nC1 ="<<c1.get_count(); cout<<"\nC2 ="<<c2.get_count(); getch(); }



Output:

C1=0 C2=O C1=1 C2=2

Result: Thus the C++ program for Unary Operator Overloading was created, executed and

output was verified successfully.



Ex.No:1(c) INHERITANCE

Aim: To write a C++ program for implementing the inheritance.

Algorithm:

1. Start the process. 2. Define the base class with variables and functions. 3. Define the derived class with variables and functions. 4. Get two values in main function. 5. Define the object for derived class in main function. 6. Access member of derived class and base class using the derived class object. 7. Stop the process.

Program:

#include<iostream.h> #include<conio.h> class base { public: int x; void set_x(int n) {x=n; } void show_x() { cout<<”\n\t Base class….”; cout<<”\n\tx=”<<x; } }; class derived:public base { int y; public: void set_y(int n) { y=n; } void show_xy() { cout<<”\n\n\t derived class…”; cout<<”\n\tx=”<<x; cout<<”\n\ty=”<<y; } }; void main() { derived obj; int x,y;



clrscr(); cout<<”\n enter the value of x: ”; cin>>x; cout<<”\n enter the value of y: ”; cin>>y; obj.set_x(x);//inherits base class obj.set_y(y);//acess member of derived class obj.show_x();//inherits base class obj.show_xy();//acess member of derived class getch(); } Output:

enter the value of x 10 enter the value of y 20 base class…. x=10 derived class….. x=10 y=20 Result:

Thus the C++ program for inheritance was created, executed and output was verified

successfully.



Ex.No: 1(d) FUNCTION OVERLOADING

Aim:

To write a C++ program for implementing the function overloading. Algorithm:

1. Define a class test. 2. Define the function sum with different arguments with different data types. 3. Define the object for the class test in main function. 4. Call the function using the argument type to perform different operations. 5. Print the output.

Program:

#include<iostream.h> #include<conio.h> class test { public: int sum(int,int); float sum(float,float); double sum(double,double); }; int test::sum(int a, int b) { return(a+b); } float test::sum(float a ,float b) { return(a+b); } double test::sum(double a, double b) { return(a+b); } void main() { test obj; int choice,ans; int a,b; float x,y; double m,n; double result=0; clrscr(); cout<<"\n\t\t main menu"; cout<<"\n\t1. Addition of two integer numbers"; cout<<"\n\t2. Addition of two float numbers"; cout<<"\n\t3. Addition of two double numbers"<<endl; do { cout<<"\n enter your choice:"; cin>>choice;



switch(choice) { case 1: cout<<"\n enter 2 numbers"; cin>>a>>b; result=obj.sum(a,b); break; case 2: cout<<"\n enter 2 number"; cin>>x>>y; result=obj.sum(x,y); break; case 3: cout<<"\n enter 2 number"; cin>>m>>n; result=obj.sum(m,n); break; default: cout<<"wrong choice"; break; } cout<<"\n\n result"<<result<<endl; cout<<"\ndo you want to continue:"; ans=getch(); } while(ans=='y'||ans=='Y'); getch(); }



Output:

Main menu 1. Addition of two integer numbers 2. Addition of two float numbers

3. Addition of two double numbers enter your choice 1 enter 2 number 2 3 result 5 do you want to continue: y

enter your choice 2 enter 2 number 1.13 5.6 result 6.73

do you want to continue: y

enter your choice 3 enter 2 number 345 354 result 699 do you want to continue: n

Result: Thus the C++ program for function Overloading was created, executed and output

was verified successfully.



Ex.No:2 ARRAY IMPLEMENTATION OF LIST ADT

Aim:

To write a C++ program for array implementation of List ADT. Algorithm:

1. Start the Program 2. Create the array b[20]. 3. Do the following operations on the list using arrays

i. Creation of list ii. Display of list iii. insertion of any element in the list iv. Deletion of any element in the list v. Searching of desired element in the list

Program

#include<iostream.h> #include<conio.h> #include<process.h> void create(); void insert(); void deletion(); void search(); void display(); int a,b[20],n,d,e,f,i; void main() { int c; clrscr(); cout<<"\n Main Menu"; cout<<"\n 1.Create \n 2.Delete \n 3.Search \n 4.insert \n 5.Display \n 6.Exit"; do { cout<<"\n enter your choice:"; cin>>c; switch(c) { case 1: create(); break; case 2: deletion(); break; case 3: search(); break; case 4: insert(); break; case 5: display(); break; case 6: exit(0); break; default: cout<<"The given number is not between 1-5\n"; } } while(c<=6); getch(); }



void create() { cout<<"\n Enter the number of elements you want to create: "; cin>>n; cout<<"\nenter the elements\n"; for(i=0;i<n;i++) { cin>>b[i]; }} void deletion() { cout<<"Enter the number u want to delete \n"; cin>>d; for(i=0;i<n;i++) { if(b[i]==d) { b[i]=0; cout<<d<<" deleted"; } } } void search() { cout<<"Enter the number \n"; cin>>e; for(i=0;i<n;i++) { if(b[i]==e) { cout<<"Value found the position\n"<<i+1; } } } void insert() { cout<<"\nenter how many number u want to insert: "; cin>>f; cout<<"\nEnter the elements\n"; for(i=0;i<f;i++) { cin>>b[n++]; }} void display() { for(i=0;i<n;i++) { cout<<"\n"<<b[i]; } }



Output

Main Menu

1.Create

2.Delete

3.Search

4.insert

5.Display

6.Exit

enter your choice:1

Enter the number of elements you want to create: 3

enter the elements

1

2

3

enter your choice:5

1

2

3

enter your choice:4

enter how many number u want to insert: 2

Enter the elements

5

7

enter your choice:5

1

2

3

5

7

enter your choice:3

Enter the number

5

Value found the position

4

enter your choice:2

Enter the number u want to delete

2

2 deleted

enter your choice:6

Result:



Thus the C++ program for array implementation of list ADT was created, executed and output was verified successfully.

Ex.No:3 LINKED LIST IMPLEMENTATION OF LIST ADT

Aim:

To write a C++ program to implement a linked list and do all operations on it. Algorithm:

1. Start the process. 2. Initialize and declare variables. 3. Enter the choice. 4. If choice is INSERT then

a. Enter the element to be inserted.

b. Get a new node and set DATA[NEWNODE] = ITEM.

c. Find the node after which the new node is to be inserted.

d. Adjust the link fields.

e. Print the linked list after insertion.

5. If choice is DELETE then

a. Enter the element to be deleted.

b. Find the node containing the element (LOC) and its preceding node (PAR).

c. Set ITEM = DATA[LOC] and delete the node LOC.

d. Adjust the link fields so that PAR points to the next element. ie LINK[PAR] = LINK [ LOC].

e. Print the linked list after deletion.

6. Stop the process. Program: #include<iostream.h> #include<conio.h> #include<lib.h> #define TRUE 1 #define FALSE 0 class sll { private: struct node { int data;



struct node *next; }*head; public: sll(); void create(); void display(); void search(int key); void insert_head(); void insert_after(); void insert_last(); void dele(); ~sll(); }; sll::sll() { head=NULL; } sll::~sll() { node *temp,*temp1; temp=head->next; delete head; while(temp!=NULL) { temp1=temp->next; delete temp; temp=temp1; } } void sll::create() { node *temp,*New; int val,flag; char ans='y'; flag=TRUE; do { cout<<"\n\nEnter the data:"; cin>>val; New=new node; if(New==NULL) cout<<"unable to allocate memory\n"; New->data=val; New->next=NULL; if(flag==TRUE)//executed only for the first time { head=New; temp=head; flag=FALSE; } else {



temp->next=New; temp=New; } cout<<"\n do you want to enter more elements?(y/n)"; ans=getch(); } while(ans=='y'||ans=='Y'); cout<<"\n the singly linked list is created\n"; getch(); } void sll::display() { node *temp; temp=head; if(temp==NULL) { cout<<"\n the list is empty\n"; getch(); clrscr(); return; } while(temp!=NULL) { cout<<temp->data<<" "; temp=temp->next; } getch(); } void sll::search(int key) { node *temp; int found; temp=head; if(temp==NULL) { cout<<"linked list is empty\n"; getch(); clrscr(); } found=FALSE; while(temp!=NULL&&found==FALSE) { if(temp->data!=key) temp=temp->next; else found=TRUE; } if(found==TRUE) { cout<<"\n the element is present in the list\n"; getch(); } else



{ cout<<"\nThe element is not present in the list\n"; getch(); } } void sll::dele() { node *temp,*prev; int key; temp=head; cout<<"\n Enter the data of the node you want to delete: "; cin>>key; while(temp!=NULL) { if (temp->data==key)//traverse till required node to delete break; //is found prev=temp; temp=temp->next; } if(temp==NULL) cout<<"\n node not found"; else { if(temp==head)//first node head=temp->next; else prev->next=temp->next; //intermediate or end node delete temp; cout<<"\n the element is deleted\n"; } getch(); } void sll::insert_last() { node *New,*temp; cout<<"\n Enter the element which you want to insert: "; cin>>New->data; if(head==NULL) head=New; else { temp=head; while(temp->next!=NULL) temp=temp->next; temp->next=New; New->next=NULL; } } void sll::insert_after() { int key; node *temp,*New; New=new node;



cout<<"\n Enter the element which you want to insert: "; cin>>New->data; if(head==NULL) { head=New; } else { cout<<"\n Enter the element after which you want to insert the node: "; cin>>key; temp=head; do { if(temp->data==key) { New->next=temp->next; temp->next=New; break; } else temp=temp->next; } while(temp!=NULL); } } void sll::insert_head() { node *New,*temp; New=new node; cout<<"\n Enter the element which you want to insert: "; cin>>New->data; if(head==NULL) head=New; else { temp=head; New->next=temp; head=New; } } void main() { sll s; int choice,val, ch1; char ans='y'; clrscr(); cout<<"\n\n\tProgram to perform various operations on linked list"; cout<<"\n1.Create"; cout<<"\n2.Display"; cout<<"\n3.Search"; cout<<"\n4.Insert an element in a list"; cout<<"\n5.Delete an element from list";



cout<<"\n6.Quit"; do { cout<<"\n\nEnter your choice(1-6): "; cin>>choice; switch(choice) { case 1: s.create(); break; case 2:s.display(); break; case 3:cout<<"enter the element you want to search"; cin>>val; s.search(val); break; case 4: clrscr(); cout<<"\n the list is:\n"; s.display(); cout<<"\n menu"; cout<<"\n1.insert at beginning "; cout<<"\n2.insert after"; cout<<"\n3.insert at end"; cout<<"\n enter your choice"; cin>>ch1; switch(ch1) { case 1:s.insert_head(); break; case 2:s.insert_after(); break; case 3:s.insert_last(); break; default:cout<<"\n invalid choice"; } break; case 5:s.dele(); break; case 6:exit(0); default:cout<<"\n invalid choice"; } cout<<"\nDo you want to continue? "; cin>>ans; } while(ans=='y'||ans=='Y'); return; } Output Program to perform various operations on linked list 1. Create 2. Display



3. Search 4. Insert an element in a list 5. Delete an element from list 6. Quit Enter your choice(1-6): 1 Enter the data:1 do you want to enter more elements?(y/n) Enter the data:2 do you want to enter more elements?(y/n) Enter the data:3 do you want to enter more elements?(y/n) the singly linked list is created Do you want to continue? y Enter your choice(1-6): 2 1 2 3 Do you want to continue? y Enter your choice(1-6): 3 enter the element you want to search2 the element is present in the list Do you want to continue? Y Enter your choice(1-6): 4 the list is: 1 2 3 menu 1.insert at beginning 2.insert after 3.insert at end enter your choice1 Enter the element which you want to insert: 4 Do you want to continue? y Enter your choice(1-6): 5 Enter the data of the node you want to delete: 2 the element is deleted Do you want to continue? y Enter your choice(1-6): 5 Enter the data of the node you want to delete: 12 node not found Do you want to continue? y Enter your choice(1-6): 6 Result:

Thus the C++ program for linked list implementation of list ADT was created, executed and output was verified successfully.



Ex.No:4 CURSOR IMPLEMENTATION – LIST ADT

Aim: To write a C++ program for cursor implementation of list ADT. Algorithm:

1. Start the program. 2. Create a node with two fields data and link field.

o Allocate space for the node dynamically. o Create link between the created nodes and let the last node be with NULL

Link o Insert the input data in the data field and press –1 to stop the same.

3. Get the choice of operations either insertion or deletion. 4. For insertion get the position in which insertion is to be done and the element to be

inserted. Check for the start, middle or end position of insertion. Insert the node and change its link accordingly.

5. For deletion get the position in which deletion is to be done. Delete the node and then link it to the next node. Before deletion check whether there is data in the list to be deleted.

6. Using display option lists the elements of the list. 7. Stop the program.

Program:

#include<iostream.h> #include<conio.h> #include<stdlib.h> #define MAX 20 class LIST { private: int List[MAX]; public: int create(); void display(int); void reverse(int); int search(int); void delet(int); }; int LIST::create() { int n,i; cout<<"\n how many elements you want in the list:"; cin>>n; if(n>MAX) cout<<"\n Error:Number of elements exceeds the limit"; for(i=0;i<n;i++) { cout<<"\nEnter the element number"<<i+1<<":";



cin>>List[i]; } cout<<"\n The List is successfully created\n"; return(n); } void LIST::display(int n) { int i; cout<<"\n the list is:\n"; for(i=0;i<n;i++) cout<<"\n"<<List[i]; } void LIST::reverse(int n) { int i; cout<<"\n the reversed list is:.\n"; for(i=n-1;i>=0;i--) cout<<"\n"<<List[i]; } int LIST::search(int n) { int i,key; cout<<"\n enter the number you want to search?"; cin>>key; for (i=0;i<n;i++) { if(List[i]==key) { cout<<"\n the given number is at position:"<<i<<"\n"; return i; } } cout<<"\n the given number is not in the list\n"; return -1; } void LIST::delet(int n) { int i; i=search(n); if(i!=NULL) { List[i]=-1; cout<<"Element deleted"; } } void main() { LIST obj; int choice,len,position; char ans; clrscr(); cout<<"\n\t program to perform operations on ordered list"; cout<<"\n 1.create";



cout<<"\n 2.display"; cout<<"\n 3.search for a number"; cout<<"\n 4.reverse"; cout<<"\n 5.delete"; cout<<"\n 6.Quit"; do { cout<<"\n enter your choice(1-6)"; cin>>choice; switch(choice) { case 1: len=obj.create(); break; case 2: obj.display(len); break; case 3: position=obj.search(len); break; case 4: obj.reverse(len); break; case 5: obj.delet(len); break; case 6: exit(0); break; default: cout<<"\n invalid choice, try again"; break; } getch(); }while(choice!=6); }

Output program to perform operations on ordered list 1.create 2.display 3.search for a number 4.reverse 5.delete 6.Quit enter your choice(1-6)1 how many elements you want in the list:3 Enter the element number1:7 Enter the element number2:3



Enter the element number3:5 The List is successfully created enter your choice(1-6)2 the list is: 7 3 5 enter your choice(1-6)4 the reversed list is:. 5 3 7 enter your choice(1-6)3 enter the number you want to search?3 the given number is at position:1 enter your choice(1-6)5 enter the number you want to search?5 the given number is at position:2 Element deleted enter your choice(1-6)2 the list is: 7 3 -1 enter your choice(1-6)6 Result:

Thus the C++ program for cursor implementation of list ADT was created, executed

and output was verified successfully.



Ex.No:5(a) ARRAY IMPLEMENTION OF STACK ADT

Aim: To write a C++ program for stack using array implementation. Algorithm:

Step1:Define a array which stores stack elements.. Step 2: The operations on the stack are

a)PUSH data into the stack b)POP data out of stack Step 3: PUSH DATA INTO STACK

3a.Enter the data to be inserted into stack. 3b.If TOP is NULL the input data is the first node in stack. the link of the node is NULL. TOP points to that node. 3c.If TOP is NOT NULL the link of TOP points to the new node. TOP points to that node. Step 4: POP DATA FROM STACK 4a.If TOP is NULL the stack is empty 4b.If TOP is NOT NULL the link of TOP is the current TOP. the pervious TOP is popped from stack. Step 5. The stack represented by linked list is traversed to display its content.

Program:

#include<iostream.h> #include<conio.h> #include<stdlib.h> class stack { int stk[5]; int top; public: stack() { top=-1; } void push(int x) {



if(top > 4) { cout <<"stack over flow"; return; } stk[++top]=x; cout <<"inserted" <<x; } void pop() { if(top <0) { cout <<"stack under flow"; return; } cout <<"deleted" <<stk[top--]; } void display() { if(top<0) { cout <<" stack empty"; return; } for(int i=top;i>=0;i--) cout <<stk[i] <<" "; } }; main() { int ch; stack st; clrscr(); cout <<"\n1.push \n2.pop \n3.display \n4.exit"; while(1) { cout<<"\nEnter ur choice"; cin >> ch; switch(ch) { case 1: cout <<"enter the element"; cin >> ch; st.push(ch); break; case 2: st.pop(); break; case 3: st.display();break; case 4: exit(0); } } return (0); }



Output:

1.push 2.pop 3.display 4.exit Enter ur choice: 1 enter the element: 3 inserted3 Enter ur choice: 1 enter the element: 5 inserted: 5 Enter ur choice: 1 enter the element: 7 inserted: 7 Enter ur choice: 3 7 5 3 Enter ur choice: 2 Deleted: 7 Enter ur choice: 3 5 3 Enter ur choice:4

Result:

Thus the C++ program for array implementation of stack ADT was created, executed

and output was verified successfully.



Ex. No:5(b) STACK ADT USING LINKED LIST Aim: To write a C++ program for stack ADT using linked list implementation.

Algorithm: Step1:Define a struct for each node in the stack. Each node in the stack contains data and link to the next node. TOP pointer points to last node inserted in the stack. Step 2: The operations on the stack are

a)PUSH data into the stack b)POP data out of stack

Step 3: PUSH DATA INTO STACK 3a.Enter the data to be inserted into stack. 3b.If TOP is NULL the input data is the first node in stack. the link of the node is NULL. TOP points to that node. 3c.If TOP is NOT NULL the link of TOP points to the new node. TOP points to that node. Step 4: POP DATA FROM STACK 4a.If TOP is NULL the stack is empty 4b.If TOP is NOT NULL the link of TOP is the current TOP. the pervious TOP is popped from stack. Step 5. The stack represented by linked list is traversed to display its content.

Program:

#include<iostream.h> #include<conio.h> #include<stdlib.h> class Linked_list_Stack { private: struct node { int data; node *next; }; node *top; node *entry; node *print;



node *bottom; node *last_entry; node *second_last_entry; public: Linked_list_Stack( ); void pop( ); void push( ); void print_list( ); void show_working( ); }; Linked_list_Stack::Linked_list_Stack ( ) { top=NULL; bottom=NULL; } void Linked_list_Stack::push( ) { int num; cout<<"\n\t Enter value to push onto Stack : "; cin>>num; entry=new node; if(bottom==NULL) { entry->data=num; entry->next=NULL; bottom=entry; top=entry; } else { entry->data=num; entry->next=NULL; top->next=entry; top=entry; } cout<<"\n\t *** "<<num<<" is pushed onto the Stack."<<endl; } void Linked_list_Stack::pop( ) { if(bottom==NULL) cout<<"\n\t *** Error : Stack is empty. \n"<<endl; else { for(last_entry=bottom;last_entry->next!=NULL; last_entry=last_entry->next) second_last_entry=last_entry; if(top==bottom) bottom=NULL; int poped_element=top->data; delete top; top=second_last_entry; top->next=NULL; cout<<"\n\t *** "<<poped_element<<" is poped from the Stack."<<endl;



} } void Linked_list_Stack::print_list( ) { print=bottom; if(print!=NULL) cout<<"\n\t Values pushed onto Stack are : \n"<<endl; else cout<<"\n\t *** Nothing to show. "<<endl; while(print!=NULL) { cout<<"\t "<<print->data<<endl; print=print->next; } } void Linked_list_Stack::show_working( ) { int choice; clrscr( ); cout<<"\n\n********** Implementation of Linked List as a Stack **********"<<endl; cout<<"\n1.Push elements to stack"<<endl; cout<<"2.Pop elements to stack"<<endl; cout<<"3.Print the elements of stack"<<endl; cout<<"4.Exit"<<endl; do { cout<<"\nEnter your Choice : "; cin>>choice; switch(choice) { case 1: push(); break; case 2: pop(); break; case 3: print_list( ); break; case 4: exit(0); break; default: cout<<"enter the valid choice"; } }while(1); } int main( ) { Linked_list_Stack obj; obj.show_working( ); return 0; }



Output:

********** Implementation of Linked List as a Stack ********** 1.Push elements to stack 2.Pop elements to stack 3.Print the elements of stack 4.Exit Enter your Choice : 1 Enter value to push onto Stack : 3 *** 3 is pushed onto the Stack. Enter your Choice : 1 Enter value to push onto Stack : 5 *** 5 is pushed onto the Stack. Enter your Choice : 1 Enter value to push onto Stack : 7 *** 7 is pushed onto the Stack. Enter your Choice : 3 Values pushed onto Stack are : 3 5 7 Enter your Choice : 2 *** 7 is poped from the Stack. Enter your Choice : 3 Values pushed onto Stack are : 3 5 Enter your Choice : 4 Result:

Thus the C++ program for stack ADT using linked list was created, executed and

output was verified successfully.



Ex. No:6(a) PROGRAM SOURCE FILES FOR STACK APPLICATION1

Application 1: checking well formedness of parenthesis.

A) STACK IMPLEMENTED AS ARRAYS(USING THE HEADER FILE OF STACK

OPERATIONS)

Step 1: Crate a header file named stack.h . in this file we will declare the class and all the stack operations. the implementation of stack is using arrays. stack.h #define size 10 class stk_class { private: /*stack structure*/ struct stack{ char s[size]; int top; }st; public: stk_class(); void push(char item); int stempty(); char pop(); }; stk_class::stk_class() { st.top=-1; } /* the push function input:item which is to be pished output:none –simply pushes the item onto the stack called by: main calls: one */ void stk_class::push(char item) { st.top++; st.s[st.top]=item; } /* the stempty function input:none output:returns 1 or 0 for stack empty or not called by:none */ int stk_class::stempty() {



inr(st.top==-1) return 1; else return 0; } /* the stfull function input:none coutput:returns 1 or 0 for stack full or not called by :main calls:none */ int stk_class::stfull() { if(st.top==size) return 1; else return 0; } /* the pop function input:none output:returns the item which is poped from the stack called by: main calls:none */ char stk_class::pop() { char item; item=st.s[st.top]; st.top--; return(item); } Step 2: Now we will create a stack application program. We have chosen an application as “checking well formedness of parenthesis” for this application we will use stack operations. These operations are used from the external file stack.h. Hence we will include this file in the include file section. Here is an application program. /************************************************************************ program for checking the well formedness of the parenthesis using stack as arrays. ************************************************************************/ #include<iostream.h> #include<conio.h> #include<stdlib.h> #include “d:\stack1.h” #define size 10 /*



the main function input:none ouput:none called by:O.S calls:push,pop,stempty */ void main(void) { char item; char ans,bracket[10]; stk_class obj; int I; clrscr(); cout<,”\n\t\t program for stack application using separate header file”; cout<<”\n enter the expression and put $at end “; cin>>bracket; i=0; if(bracket[i]==’)’) cout<<”\n the expressin is invalid”; else { do { while(brackt[i]==’(‘) { obj.push(bracket[i]); i++; } while(bracket[i]==’)’) { item=obj.pop(); i++; } } while(brackt[i]!=’$’) if(!obj.stempty()) cout<<”\n the expression is invalid”; else cout<<”\n the expression has well formed parenthesis”; } getch(); } Step 3: Execute above program and following output can be obtained.



Output(run 1)

program for stack application using separate header file enter the expression and put $ at the end (()(()))$ the expression has well formed parenthesis

Output(run 2) program for stack application using separate header file enter the expression and put $ at the end (()()$ the expression in invalid.

Result:

Thus the C++ program for balanced parantheses checking using array

implementation of stack ADT was created, executed and output was verified successfully.



B) STACK IMPLEMENTED AS LINKED LIST(USING THE HEADER FILE OF STACK OPERATION)

step 1: create a header file named stack. In this file we declare the class and all the stack operations. The implementation of stack using linked list. /********************************** the stack.h file ***********************************/ class stk_class { private: /*data structure for the linked stack*/ typedef struct stack { char data; struct stack * next; }node; node *top; public: stk_class(); void push(char item); int sempty(); void pop(); }; stk_class ::stk_class() { top=NULL; } /* functionality performed on linked stack*/ void stk_class::push(char item) { node * New; New=new node; if(New==NULL) cout<<”\n memory cannot be allocated \n”; else { New->data=item; new->next=top; top=New; } } /* the sempty function input: any node for checking the empty condition output:1 or 0 for empty or not condition called by: main calls: none */ int stk_class::sempty()



{ if(top==NULL) return 1; else return 0; } /* ……………………………………… the pop function input: the top of the stack called by: main calls:none ……………………………………………*/ void stk_class::pop() { node *temp; temp=top; top=top->next; delete temp;} Step 2: Now we will create a stack application program. We have chosen an application as “checking well formedness of parenthesis” for this application we will use stack operations. These operations are used from the external file stack.h. Hence we will include this file in the include file section. Here is an application program. /*………………………………………………………………………………………… Program for checking the well – formedness of the parenthesis using linked stack. ……………………….…………………………………………………………………..*/ /*include file section*/ #include<iostream.h> #include<conio.h> #include<process.h> #include<stdlib.h> /* Included linked stack as a header file*/ #include<”d:\stack.h” /* the main function input:none output:none called by:O.S calls:push ,pop,sempty */ void main(void) { char ans,bracket[10]; Char data ,item; stk_class obj; int choice; int I; clrscr(); cout<<”\n\t\t enter the expression and put $ at the end “;



cin>>bracket; i=0; if(bracket[i]==’)’) cout<<”\n the expression is invalid”; else { do { if(bracket[i]==’(‘) { obj.push(bracket[i]); } else if(bracket[i]==’)’) { if(obj.sempty()) { cout<<”\n the expression is invalid”; getch(); exit(0); } obj.pop(); } i++; } while(bracket[i]!=’$’); if(obj.sempty()) cout<<”\n the expression is invalid”; else cout<<”\n the expression has well formed parenthesis”; } getch(); } Step 3:

The above program will be executed to get output as follows

output(run1) enter the expression and put $ at the end ()()$ the expression has well formed parenthesis

output(run 2) enter the expression and put $ at the end (()()$ the expression is invalid. Result:

Thus the C++ program for balanced parantheses checking using linked list implementation of stack ADT was created, executed and output was verified successfully.



Ex. No:6(b) PROGRAM SOURCE FILES FOR STACK APPLICATION2

application 2: Evaluation of postfix expression.

A.USING STACK(IMPLEMENTATION AS ARRAYS)

STEP 1:

/******************************************** stack.h *********************************************/ #define Max 10 class stk_class { /*declaration of stack data structure*/ struct stack { double s[MAX]; int top; }st; public: stk_class(); void push(double val); double pop(); }; stk_class::stk_class() { st.top=0; } void stk_class::push(double val) { if(st.top+1>=MAX) cout<<”\n stack is full”; st.top++; st.s[st.top]=val; } double stk_class::pop() { double val; if(st.top==-1) cout<<”\n stack is empty\n”; st.top--; return(val);l } STEP 2: /************************************************************************ program to evaluate a given postfix expression .her the stack using arrays is implemented in separate file named stack.h



************************************************************************/

#include<iostream.h> #include<conio.h> #include<stdlib.h> #include<string.h> #include<math.h> /*included the header file as stack using array*/ #define size 80 void main() { char exp[size]; int len; double result; double post(char exp[]); clrscr(); cout<<”enter the postfix expression\n”; cin>>exp; len=strlen(exp); exp[len]=’$’;/*append $ at the end a end marker*/ result=post(exp); cout<<”the value of the expression is”<<result; getch(); exit(0); } double post(char exp[]) { stk_class obj; char ch,*type; double result ,val,op1,op2; int i; i=0; ch=exp[i]; while(ch!=’$’) { if(ch>=’0’&&ch<=’9’) type=””operand”: else if(ch==’+’||ch==’-‘||ch==’^’) type=”operator”; if(strcmp(type,”operand”)==0)/* if the character is operator*/ { val=ch-48; obj.push(val); } else if(strcmp(type,”operator”)==0)/* if it is operator*/ { op2=obj.pop(); op1=obj.pop(); switch(ch) {



case ‘+’:result=op1+op2; break; case ‘-‘:result=op1-op2; break; case ‘*;:result=op1*op2; break; case ‘/’: result=op1/op2; break; case ‘^’:result=pow(op1,op2) break; } /*switch*/ obj.push(result); } i++; ch=exp[i]; }/*while*/ result-obj.pop();/*pop the result*/ return(result); } Output:

Enter the postfix expression 12+3* The value of the expression is 9 Result:

Thus the given program Evaluation of postfix expression stack implemented as arrays

was executed successfully.



B. STACK IMPLANTED AS LINKED LIST(USE OF SEPARATE HEADER FILE FOR STACK

OPERATIONS)

STEP 1: /********************************************************************

the stack.h file **********************************************************************/ class stk_class { /* data structure for the linked stack*/ typedef struct stack { char data; struct stack *next; }node; public: node *top; stk_class(); void push(char item); char pop(); }; stk_class::stk_class() { top=NULL: } /* functionality performed on linked linked stack*/ void stk_class::push(char item) { node *New; New=new node; New->data =Item; New->next=top; top=New; } char stk_class::pop() { char item; node *temp; item=top->data; temp=top; top=top->next; delete temp; return item; } STEP 2: /********************************************************************* program to evaluate a given postfix expression using linked stack. here stack.h is a user defined header file created for linked stack **********************************************************************/ #include<iostream.h>



#include<stdlib.h> #include<string.h> #include<math.h> #include<stdlib.h> #include<conio.h> /* included the stack.h file (given below) for linked stack*/ #include”d:\stack.h” #define size 80 void main() { char exp[size]; int len; double result; double post(char exp[]) clrscr(); cout<<”enter the postfix expression\n”; cin>>exp; len=strlen(exp); cin>>exp; len=strlen(exp); exp[len]=’$’;/*append $at the end as a endmarker*/ result=post(exp); cout<<”the value of the expression is”<<result; getch(); exit(0); } double post(char exp[]) { char ch,*type; double result ,val,oip1,op2; int I; stk_class obj; i=0; ch=exp[i]; while(ch!=’$’) { if(ch>=’0’&&ch<=’9’) type=”operand”; else if(ch==’+’||ch==’-‘||ch==’*’||ch==’/’||ch==’^’) type=”operator”; if(strcmp(type,”operator”)==0) /* if the character is operand*/ { val=ch-48; obj.push(val); } else if(strcmp(type,”operator”)==0)/*if it is operator*/ { op2=obj.pop(); op1=obj.pop(); switch(ch) {



case ‘+’:result=op1+op2; break; case ‘-‘:result=op1-op2; break; case ‘*;:result=op1*op2; break; case ‘/’: result=op1/op2; break; case ‘^’:result=pow(op1,op2) break; } /*switch*/ obj.push(result); } i++; ch=exp[i]; }/*while*/ result-obj.pop();/*pop the result*/ return(result); } Output:

enter the expression 12+3* the value of the expression is 9 Result:

Thus the given program Evaluation of postfix expression stack implemented as linked

list was executed successfully.



Ex. No7(a) QUEUE ADT OPERATIONS USING LINKED LIST

Aim: To write a C++ program for Queue using Linked implementation. Algorithm: Step1: Define a struct for each node in the queue. Each node in the queue contains data and link to the next node. Front and rear pointer points to first and last node inserted in the queue. Step 2: The operations on the queue are

a)INSERT data into the queue b)DELETE data out of queue

Step 3: INSERT DATA INTO queue 3a.Enter the data to be inserted into queue. 3b.If TOP is NULL the input data is the first node in queue. the link of the node is NULL. TOP points to that node. 3c.If TOP is NOT NULL the link of TOP points to the new node. TOP points to that node. Step 4: DELETE DATA FROM queue 4a.If TOP is NULL the queue is empty 4b.If TOP is NOT NULL the link of TOP is the current TOP. the pervious TOP is popped from queue. Step 5. The queue represented by linked list is traversed to display its content.

Program:

#include<iostream.h> #include<conio.h> #include<stdlib.h> class node { public: class node *next; int data; }; class queue : public node { node *head;



int front,rare; public: queue() { front=-1; rare=-1; } void enqueue(int x) { if (rare < 0 ) { head =new node; head->next=NULL; head->data=x; rare ++; } else { node *temp,*temp1; temp=head; if(rare >= 4) { cout <<"queue over flow"; return; } rare++; while(temp->next != NULL) temp=temp->next; temp1=new node; temp->next=temp1; temp1->next=NULL; temp1->data=x; } } void display() { node *temp; temp=head; if (rare < 0) { cout <<" queue under flow"; return; } while(temp != NULL) { cout <<temp->data<< " "; temp=temp->next; } } void dequeue() { node *temp; temp=head;



if( rare < 0) { cout <<"queue under flow"; return; } if(front == rare) { front = rare =-1; head=NULL; return; } front++; head=head->next; } }; main() { queue s1; int ch; clrscr(); cout<<"\n\n\tQUEUE USING LINKED LIST"; cout <<"\n1.enqueue\n2.dequeue\n3.DISPLAY\n4.EXIT"; while(1) { cout<<"\n enter your choice:"; cin >> ch; switch(ch) { case 1: cout <<"\n enter a element"; cin >> ch; s1.enqueue(ch); break; case 2: s1.dequeue(); break; case 3: s1.display(); break; case 4: exit(0); } } return (0); } Output QUEUE USING LINKED LIST 1.enqueue 2.dequeue 3.DISPLAY 4.EXIT



enter your choice:1 enter a element3 enter your choice:1 enter a element5 enter your choice:1 enter a element7 enter your choice:3 3 5 7 enter your choice:2 enter your choice:3 5 7 Result:

Thus the C++ program for queue ADT using linked list implementation was created, executed and output was verified successfully.



Ex. No:7(b) QUEUE ADT USING ARRAY Aim: To write a program for Queue using array implementation. Algorithm: Step1:Define a array which stores queue elements.. Step 2: The operations on the queue are

a)INSERT data into the queue b)DELETE data out of queue

Step 3: INSERT DATA INTO queue 3a.Enter the data to be inserted into queue. 3b.If TOP is NULL the input data is the first node in queue. the link of the node is NULL. TOP points to that node. 3c.If TOP is NOT NULL the link of TOP points to the new node. TOP points to that node. Step 4: DELETE DATA FROM queue 4a.If TOP is NULL the queue is empty 4b.If TOP is NOT NULL the link of TOP is the current TOP. the pervious TOP is popped from queue. Step 5. The queue represented by linked list is traversed to display its content. Program:

#include<iostream.h> #include<conio.h> #include<stdlib.h> class queue { int queue1[5]; int rear,front; public: queue() { rear=-1; front=-1; } void insert(int x) { if(rear > 4) { cout <<"queue over flow";



front=rear=-1; return; } queue1[++rear]=x; cout <<"inserted" <<x; } void delet() { if(front==rear) { cout <<"queue under flow"; return; } cout <<"deleted" <<queue1[++front]; } void display() { if(rear==front) { cout <<" queue empty"; return; } for(int i=front+1;i<=rear;i++) cout <<queue1[i]<<" "; } }; main() { int ch; queue qu; cout <<"\n1.insert 2.delete 3.display 4.exit"; while(1) { court<<"\nEnter ur choice"; cin >> ch; switch(ch) { case 1: cout <<"enter the element"; cin >> ch; qu.insert(ch); break; case 2: qu.delet();

break; case 3: qu.display();

break; case 4: exit(0); } } return (0); } \



Output: 1.insert 2.delete 3.display 4.exit Enter ur choice1 enter the element1 inserted1 Enter ur choice1 enter the element3 inserted3 Enter ur choice1 enter the element7 inserted7 Enter ur choice3 1 3 7 Enter ur choice2 deleted1 Enter ur choice3 3 7 Enter ur choice4 Result:

Thus the C++ program for queue ADT using array implementation was created, executed and output was verified successfully.



Ex. No:8 BINARY SEARCH TREE Aim: To write a C++ program for binary search tree. Algorithm:

1. Declare function create(),search(),delete(),Display(). 2. Create a structure for a tree contains left pointer and right pointer. 3. Insert an element is by checking the top node and the leaf node and the operation will

be performed. 4. Deleting an element contains searching the tree and deleting the item. 5. display the Tree elements.

Program:

#include<iostream.h> #include<conio.h> class bintree { typedef struct bst { int data; struct bst *left,*right; } node; node *root,*New,*temp,*parent; public: bintree() { root=NULL; } void create(); void display(); void delet(); void find(); void insert(node *,node*); void inorder(node *); void search(node**,int,node **); void del(node *,int); }; void bintree::create() { New=new node; New->left=NULL; New->right=NULL; cout<<"\n enter the element"; cin>>New->data; if(root==NULL) root=New; else insert(root,New);



} void bintree::insert(node *root,node *New) { if(New->data<root->data) { if(root->left==NULL) root->left=New; else insert(root->left,New); } if(New->data>root->data) { if(root->right==NULL)root->right=New; else insert(root->right,New); } } void bintree::display() { if(root==NULL) cout<<"tree is not created"; else { cout<<"\n the tree is: "; inorder(root); } } void bintree::inorder(node *temp) { if(temp!=NULL) { inorder(temp->left); cout<<" "<<temp->data; inorder(temp->right); } } void bintree::find() { int key; cout <<"\n enter the element which you want to search"; cin>>key; temp=root; search(&temp,key,&parent); if(temp==NULL) cout<<"\n element is not present"; else cout<<"\n parent of node "<<temp->data<<" is"<<parent->data; } void bintree::search(node **temp,int key,node ** parent) { if(*temp==NULL) cout<<endl<<" tree is not created"<<endl; else



{ while(*temp!=NULL) { if((*temp)->data==key) { cout<<"\n the "<<(*temp)->data<<" element is present"; break; } *parent=*temp;//stores the parent value if((*temp)->data>key) *temp=(*temp)->left; else *temp=(*temp)->right; } } return; } void bintree::delet() { int key; cout<<"\n enter the element you want to delete"; cin>>key; if(key==root->data) { bintree();// assigning a value NULL to root } else del(root,key);} void bintree::del(node *root,int key) { node *temp_succ; if(root==NULL) cout<<" tree is not created"; else { temp=root; search(&temp,key,&parent); if(temp->left!=NULL&&temp->right!=NULL) { parent=temp; temp_succ=temp_succ->left; while(temp_succ->left!=NULL) { parent=temp_succ; temp_succ=temp_succ->left; } temp->data=temp_succ->data; temp->right=NULL; cout<<" now deleted it!"; return; } if(temp->left!=NULL&&temp->right==NULL) {



if(parent->left==temp) parent->left=temp->left; else parent->right=temp->left; temp=NULL; delete temp; cout<<" now deleted it!"; return; } if(temp->left==NULL&&temp->right!=NULL) { if(parent->left==temp) parent->left=temp->right; else parent->right=temp->right; temp=NULL; delete temp; cout<<" now deleted it!"; return; } /*deleting a node which is having no child*/ if(temp->left==NULL&&temp->right==NULL) { if(parent->left==temp) parent->left=NULL; else parent->right=NULL; cout<<" now deleted it!"; return; } } } void main() { int choice; char ans='N'; bintree tr; clrscr(); cout<<"\n\t program for binary search tree"; cout<<"\n1.create\n2.search\n3.delete\n4.display"; do { cout<<"\n\n enter your choice:"; cin>>choice; switch(choice) { case 1:do { tr.create(); cout<<"do you want to enter more elements: (y/n)"<<endl; ans=getche(); } while(ans=='y');



break; case 2:tr.find(); break; case 3: tr.delet(); break; case 4: tr.display(); break; }} while(choice!=5); }



Output: program for binary search tree 1.create 2.search 3.delete 4.display enter your choice: 1 enter the element: 3 do you want to enter more elements: (y/n)y enter the element:7 do you want to enter more elements: (y/n)y enter the element:5 do you want to enter more elements: (y/n)y enter the element:10 do you want to enter more elements: (y/n)y enter the element: 56 do you want to enter more elements: (y/n)n enter your choice:4 the tree is: 3 5 7 10 56 enter your choice: 2 enter the element which you want to search: 56 the 56 element is present parent of node 56 is10 enter your choice: 3 enter the element you want to delete7 the 7 element is present now deleted it! enter your choice: 4 the tree is: 3 5 0 enter your choice: 5 Result:

Thus the C++ program for binary search tree was created, executed and output was verified successfully.



Ex. No:9 HEAP SORT Aim: To write a c program to perform heap sort. Algorithm:

1. Get the size of the array from the user. 2. Get the elements to be sorted. 3. Build a heap. 4. Sort the heap in ascending order. 5. Now the array is contained with sorted elements. 6. Display the sorted elements.

Program:

# include <iostream.h> # include <conio.h> void main() { clrscr(); int a[50],size; int p,c; cout<<"Enter the Size of an Array :"; cin>>size; cout<<"Enter Value of A[1] :"; cin>>a[1]; for(int i=2;i<=size;i++) { cout<<"Enter Value of A["<<i<<"] :"; cin>>a[i]; p=i/2; c=i; while(1) { if( a[c] > a[p]) { int t=a[c]; a[c]=a[p]; a[p]=t; } c=p; p=p/2; if(p<1) { break; } } } cout<<endl<<"Heap ..."<<endl; for(i=1;i<=size;i++) { cout<<endl;



cout<<"Arr["<<i<<"] :"<<a[i]; } int j=size; int lc,rc; while(j>1) { if(a[1] > a[j]) { int t=a[1]; a[1]=a[j]; a[j]=t; j--; } else { j--; continue; } p=1; while(p < j) { lc=p*2; rc=p*2 + 1; if(lc>=j || rc >=j) { break; } if(a[p] < a[lc] && a[lc] > a[rc]) { int temp=a[lc]; a[lc]=a[p]; a[p]=temp; p=lc; } else if (a[p] < a[rc] && a[rc] > a[lc]) { int temp=a[rc]; a[rc]=a[p]; a[p]=temp; p=rc; } else { break; } } } cout<<endl<<"\nSorted List ..."<<endl; for(i=1;i<=size;i++) {



cout<<endl; cout<<"Arr["<<i<<"] :"<<a[i]; } getch(); }

Output: Enter the Size of an Array :5 Enter Value of A[1] :3 Enter Value of A[2] :7 Enter Value of A[3] :2 Enter Value of A[4] :5 Enter Value of A[5] :1 Heap ... Arr[1] :7 Arr[2] :5 Arr[3] :2 Arr[4] :3 Arr[5] :1 Sorted List ... Arr[1] :1 Arr[2] :2 Arr[3] :3 Arr[4] :5 Arr[5] :7 Result:

Thus the C++ program for heapsort was created, executed and output was verified successfully.



Ex.No :10 QUICK SORT

Aim: To write a c program to perform quick sort. Algorithm:

1. Get the value of how many no. to be sorted.

2. Get the elements from the user.

3. Two function quicksort() and swap(). Quick sort to perform sorting.

4. Swap() is just to rearrange the values.

5. Quick sort algorithm works by partitioning the array to be sorted, then recursively

sorting each partition.

6. Display the sorted value.

Program:

# include <iostream.h> # include <conio.h> void swap(long &,long &); void quick_sort(long [],int,int); main( ) { clrscr( ); const int array_size=10; long array[array_size]={0}; cout<<" \n\n*********************** Quick Sort ******************"<<endl; cout<<"\n * Array size = 10"<<endl; cout<<" * Data Type = long"<<endl; cout<<" Enter the array : "<<endl<<endl; for(int count_1=0;count_1<array_size;count_1++) { cout<<"\t Element["<<count_1<<"] = "; cin>>array[count_1]; } quick_sort(array,0,array_size-1); cout<<" \n\nSorted Array : \n\n"; for(int count_2=0;count_2<array_size;count_2++) { cout<<"\tElement["<<count_2<<"] = "<<array[count_2]<<endl; } cout<<" \n\n\n**********************************************************"; getch( ); return 0; }



void swap(long &element_1,long &element_2) { long temp=element_1; element_1=element_2; element_2=temp; } void quick_sort(long array[],int first,int last) { if(first>=last) { } else { int middle=array[last]; int count_1=first-1; int count_2=last; while(count_1<count_2) { do { count_1++; } while(array[count_1]<middle); do { count_2--; } while(count_2>=0 && array[count_2]>middle); if(count_1<count_2) swap(array[count_1],array[count_2]); } swap(array[count_1],array[last]); quick_sort(array,first,count_1-1); quick_sort(array,count_1+1,last); } }



Output ******************************** Quick Sort ****************************** * Array size = 10 * Data Type = long Enter the array : Element[0] = 1 Element[1] =342 Element[2] = 6 Element[3] = 5 Element[4] = 34 Element[5] = 96 Element[6] = 43 Element[7] = 77 Element[8] = 45 Element[9] = 98 Sorted Array : Element[0] = 1 Element[1] = 5 Element[2] = 6 Element[3] = 34 Element[4] = 43 Element[5] = 45 Element[6] = 77 Element[7] = 96 Element[8] = 98 Element[9] = 342 *************************************************************************** Result:

Thus the C++ program for quicksort was created, executed and output was verified

successfully.

Oops and Ds Lab1

Documents

Transcript of Oops and Ds Lab1