HELLO EVERYONE.
THE FOLLOWING CODE IS WRITTEN IN C++ LANGUAGE
.
.
/*THE CONCEPTS INCLUDED IN IT ARE CLASSES, RECURSIVELY CREATING OBJECTS OF A CLASS, 'this' POINTER, CONSTRUCTOR, DESTRUCTOR .*/
//IT WILL TAKE ONLY 5 MINUTES TO UNDERSTAND THE CODE AND I AM HOPING YOU WON'T GET BORED!!!
/*
-> THE FOLLOWING CODE GIVES US THE MINIMUM NUMBER AND THE MAXIMUM NUMBER IN A GIVEN ARRAY OF 'n' ELEMENTS.
-> THE TIME COMPLEXITY OF THE CODE IS O(n). BUT YOU CAN OBSERVE THAT I AM NOT DOING IT BY SIMPLY TRAVERSING THE WHOLE ARRAY.
-> BECAUSE IF WE SIMPLY TRAVERSE THE WHOLE ARRAY LINEARLY TO FIND THE MAXIMUM AND MINIMUM NUMBERS, WE NEED TO MAKE (2*(n-1)) COMPARISONS.
-> SO, IF WE APPLY DIVIDE AND CONQUER TECHNIQUE, WE CAN REDUCE NUMBER OF COMPARISONS THAT ARE TO BE MADE.
-> AS BY NAME ITSELF, DIVIDE AND CONQUER MEANS FIRST WE DIVIDE THE ARRAY AND THEN WE APPLY OUR LOGIC ON THE TWO DIVIDED ARRAYS.
-> IT IS ALWAYS EASIER TO APPLY THE LOGIC FOR TWO SMALL ARRAYS INSTEAD OF APPLYING IT ON NEARLY DOUBLE SIZED ARRAY.
*/
//SOURCE CODE:
#include<iostream>
using namespace std;
class minmax
{
private:
int *a,mini,maxi,mid,left,right;
public:
minmax(int b[],int l,int r)
{
a=b;
left=l;
right=r;
mid=(l+r)/2;
}
minmax* getmaxmin()
{
if(left==right)
{mini=a[0];
maxi=a[0];
return this;}
if(right==left+1)
{
count++;
if(a[left]>a[left+1])
{maxi=a[left];
mini=a[left+1];}
else
{maxi=a[left+1];
mini=a[left];}
return this;
}
if(right>left+1)
{
minmax z(a,left,mid);
minmax *p=z.getmaxmin();
minmax y(a,mid+1,right);
minmax *q=y.getmaxmin();
if(p->maxi>q->maxi)
{maxi=p->maxi;}
else
{maxi=q->maxi;}
if(p->mini<q->mini)
{mini=p->mini;}
else
{mini=q->mini;}
return this;
}
}
void display()
{
cout<<"The minimum number is "<<mini<<" and the maximum number is "<<maxi<<endl;
}
};
int main()
{
int n;
cout<<"Enter the number of elements"<<endl;
cin>>n;
int a[n];
cout<<"Enter the array elements"<<endl;
for(int i=0;i<n;i++)
{
cout<<"Enter the "<<i+1<<"th number"<<endl;
cin>>a[i];
}
minmax num(a,0,n-1);
minmax *c=num.getmaxmin();
c->display();
return 0;
}
EXAMPLE
THE DETAILED EXPLANATION OF THE ABOVE CODE:
//START OF THE PROGRAM
//DEFINING THE CLASS NAMED MINMAX
//IT IS CONTAINING SOME DATA MEMBERS WHICH ARE PRIVATE. THAT MEANS, ONLY THE MEMBER FUNCTIONS OF THE SAME CLASS AND FRIEND FUNCTIONS OF THE SAME CLASS
//CAN ACCESS THOSE DATA MEMBERS.
#include<iostream>
using namespace std;
class minmax
{
private:
int *a,minimum,maximum,mid,left,right;
public:
//IT IS A CONSTRUCTOR FOR THE CLASS MINMAX
//HERE, WE ARE INTIALIZING SOME OF THE DATA MEMBERS OF THE MINMAX CLASS
//IT IS A CONSTRUCTOR FOR THE CLASS MINMAX
//HERE, WE ARE INTIALIZING SOME OF THE DATA MEMBERS OF THE MINMAX CLASS
minmax(int b[],int l,int r)
{
a=b;
left=l;
right=r;
mid=(l+r)/2;
cout<<"object is created and intialised"<<endl;
}
//BLOCK-A
//IT IS A MEMBER FUNCTION OF CLASS MINMAX WHICH HAS RETURN TYPE MINMAX*(POINTER TYPE)
//BASICALLY IT WILL RETURN THE BASE ADDRESS OF THE OBJECT OF MINMAX CLASS
//LOGIC STARTS HERE!!!!
//BLOCK-A
//IT IS A MEMBER FUNCTION OF CLASS MINMAX WHICH HAS RETURN TYPE MINMAX*(POINTER TYPE)
//BASICALLY IT WILL RETURN THE BASE ADDRESS OF THE OBJECT OF MINMAX CLASS
//LOGIC STARTS HERE!!!!
minmax* getmaxmin()
{
//BLOCK-B
//THE MAIN JOB OF THIS 'IF' BLOCK IS IF THE NUMBER OF ELEMENTS IS ONE THEN OBVIOUSLY IT WILL BE BOTH MINIMUM AND MAXIMUM NUMBER
//SO WE ARE STORING THEM RESPECTIVELY IN RESPECTIVE DATA MEMBERS
//AS MENTIONED IN BLOACK-A, WE ARE RETURNING THE BASE ADDRESS INT HE FORM OF 'this' POINTER('this' POINTER BASICALLY POINTS TO THE INTANCE OF THE CLASS(OBJECT))
//BLOCK-B
//THE MAIN JOB OF THIS 'IF' BLOCK IS IF THE NUMBER OF ELEMENTS IS ONE THEN OBVIOUSLY IT WILL BE BOTH MINIMUM AND MAXIMUM NUMBER
//SO WE ARE STORING THEM RESPECTIVELY IN RESPECTIVE DATA MEMBERS
//AS MENTIONED IN BLOACK-A, WE ARE RETURNING THE BASE ADDRESS INT HE FORM OF 'this' POINTER('this' POINTER BASICALLY POINTS TO THE INTANCE OF THE CLASS(OBJECT))
if(left==right)
{
minimum=a[0];
maximum=a[0];
return this;
}
//BLOCK-C
//THE MAIN JOB OF THIS 'IF' BLOCK IS IF THE NUMBER OF ELEMENTS IS EXACTLY TWO THEN WE WILL COMPARE THOSE TWO ELEMENTS.
//NOW WE WILL STORE THEM IN THEIR RESPECTIVE DATA MEMBERS
//BLOCK-C
//THE MAIN JOB OF THIS 'IF' BLOCK IS IF THE NUMBER OF ELEMENTS IS EXACTLY TWO THEN WE WILL COMPARE THOSE TWO ELEMENTS.
//NOW WE WILL STORE THEM IN THEIR RESPECTIVE DATA MEMBERS
if(right==left+1)
{
if(a[left]>a[left+1])
{
maximum=a[left];
minimum=a[left+1];
}
else
{
maximum=a[left+1];
minimum=a[left];
}
return this;
}
//AS MENTIONED IN BLOACK-A, WE ARE RETURNING THE BASE ADDRESS IN THE FORM OF 'this' POINTER('this' POINTER BASICALLY POINTS TO THE INTANCE OF THE CLASS(OBJECT))
//AS MENTIONED IN BLOACK-A, WE ARE RETURNING THE BASE ADDRESS IN THE FORM OF 'this' POINTER('this' POINTER BASICALLY POINTS TO THE INTANCE OF THE CLASS(OBJECT))
//BLOCK-C
//HERE COMES THE MASTERPIECE!!
//THE MAIN JOB OF THIS 'IF' BLOCK IS IF THE NUMBER OF ELEMENTS IS GREATERTHAN TWO WE WILL CALCULATE THE MIDDLE INDEX VALUE
//NOW WE WILL CREATE AN OBJECT OF OUR CLASS MINMAX. THE OBJECT IS NAMED AS 'z' AND WE ARE PASSING THE ARRAY BASE ADDRESS, LEFTMOST INDEX AS LEFT AND MID VALUE AS RIGHTMOST INDEX.
//HERE COMES THE MASTERPIECE!!
//THE MAIN JOB OF THIS 'IF' BLOCK IS IF THE NUMBER OF ELEMENTS IS GREATERTHAN TWO WE WILL CALCULATE THE MIDDLE INDEX VALUE
//NOW WE WILL CREATE AN OBJECT OF OUR CLASS MINMAX. THE OBJECT IS NAMED AS 'z' AND WE ARE PASSING THE ARRAY BASE ADDRESS, LEFTMOST INDEX AS LEFT AND MID VALUE AS RIGHTMOST INDEX.
if(right>left+1)
{
//BLOCK-D
//NOW WE CREATED A POINTER OF CLASS MINMAX AND STORING THE BASE ADDRESS OF THE OBJECT RETUTRNED BY THE 'getmaxmin' MEMBER FUNTION WHICH IS INVOKED BY THE OBJECT 'z'.
//BLOCK-D
//NOW WE CREATED A POINTER OF CLASS MINMAX AND STORING THE BASE ADDRESS OF THE OBJECT RETUTRNED BY THE 'getmaxmin' MEMBER FUNTION WHICH IS INVOKED BY THE OBJECT 'z'.
minmax z(a,left,mid);
minmax *p=z.getmaxmin();
minmax y(a,mid+1,right);
//SIMILARLY WE ARE DOING FOR THE RIGHT PART OF ARRAY WHICH IS ON RIGHT SIDE OF MID VALUE
//SIMILARLY WE ARE DOING FOR THE RIGHT PART OF ARRAY WHICH IS ON RIGHT SIDE OF MID VALUE
minmax *q=y.getmaxmin();
//SIMILARLY WE CREATED ONE POINTER AND STORED THE BASE ADDRESS
//SIMILARLY WE CREATED ONE POINTER AND STORED THE BASE ADDRESS
if(p->maximum>q->maximum)
//NOW WE ARE COMPARING THE BOTH MAMIMUM VALUES AND STORING THE MAXIMUM VALUE IN CURRENT 'MAXIMUM' DATA MEMBER
//NOW WE ARE COMPARING THE BOTH MAMIMUM VALUES AND STORING THE MAXIMUM VALUE IN CURRENT 'MAXIMUM' DATA MEMBER
{
maximum=p->maximum;
}
else
{
maximum=q->maximum;
}
if(p->minimum<q->minimum)
//NOW WE ARE COMPARING THE BOTH MINIMUM VALUES AND STORING THE MINIMUM VALUE IN CURRENT 'MINIMUM' DATA MEMBER
//NOW WE ARE COMPARING THE BOTH MINIMUM VALUES AND STORING THE MINIMUM VALUE IN CURRENT 'MINIMUM' DATA MEMBER
{
minimum=p->minimum;
}
else
{
minimum=q->minimum;
}
return this;
//AS MENTIONED IN BLOACK-A, WE ARE RETURNING THE BASE ADDRESS INT HE FORM OF 'this' POINTER('this' POINTER BASICALLY POINTS TO THE INTANCE OF THE CLASS(OBJECT))
//AS MENTIONED IN BLOACK-A, WE ARE RETURNING THE BASE ADDRESS INT HE FORM OF 'this' POINTER('this' POINTER BASICALLY POINTS TO THE INTANCE OF THE CLASS(OBJECT))
}
}
//LOGIC ENDS HERE!!!!
// THIS IS ANOTHER MEMBER FUNCTION WHICH IS USED TO DISPLAY MINIMUM NUMBER AND MAXIMUM NUMBER
//LOGIC ENDS HERE!!!!
// THIS IS ANOTHER MEMBER FUNCTION WHICH IS USED TO DISPLAY MINIMUM NUMBER AND MAXIMUM NUMBER
void display()
{
cout<<"the minimum number is "<<minimum<<" and the maximum number is "<<maximum<<endl;
}
//DESTRUCTOR
//DESTRUCTOR
~minmax()
{
cout<<"object is destructed"<<endl;
}
};
int main()
//OUR MAIN FUNCTION STARTS HERE
//OUR MAIN FUNCTION STARTS HERE
{
int n;
cout<<"enter the number of elements"<<endl;
cin>>n;
// WE ARE TAKING NUMBER OF ELEMENTS OF AN ARRAY AS A INPUT FROM THE USER
// WE ARE TAKING NUMBER OF ELEMENTS OF AN ARRAY AS A INPUT FROM THE USER
int a[n];
cout<<"enter the array elements"<<endl;
for(int i=0;i<n;i++)
{
cout<<"enter the "<<i+1<<"th number"<<endl;
//STORING ARRAY ELEMENTS
//STORING ARRAY ELEMENTS
cin>>a[i];
}
minmax num(a,0,n-1);
//CREATING AN OBJECT OF OUT MINMAX CLASS. OBJECT NAME IS 'num'
//CREATING AN OBJECT OF OUT MINMAX CLASS. OBJECT NAME IS 'num'
minmax *c=num.getmaxmin();
//WE ARE DOING THE SAME THING WHICH WE DID IN BLOCK-D
//WE ARE DOING THE SAME THING WHICH WE DID IN BLOCK-D
c->display();
//FINALLY WE ARE DISPLAYING THE MINIMUM NUMBER AND MAXIMUM NUMBER IN THE GIVEN ARRAY
//FINALLY WE ARE DISPLAYING THE MINIMUM NUMBER AND MAXIMUM NUMBER IN THE GIVEN ARRAY
return 0;
}
//END OF THE PROGRAM
//END OF THE PROGRAM
//THANK YOU
SOME RELATED LINKS:
https://www.geeksforgeeks.org/maximum-and-minimum-in-an-array/
ABOUT ME
MYSELF SUJITH SAGAR. I AM A B.tech SECOND YEAR COMPUTER SCIENCE AND ENGINEERING STUDENT AT NATIONAL INSTITUTE OF TECHNOLOGY DELHI.
Linkedin profile: www.linkedin.com/in/sujith-sagar-gandi-2b3544179
THANK YOU AMAN YADAV AND BINSHUMESH SACHAN FOR RECTIFYING ERRORS :)
Thanks alot to Nikhitha, Bhavani, Sadhana, Kailash varma, Devendhar, Manoj, Rakesh, Karthik, Koushik and all other who are sharing these posts with their Co-geeks. Once again thank you guys.
SOME RELATED LINKS:
https://www.geeksforgeeks.org/maximum-and-minimum-in-an-array/
ABOUT ME
MYSELF SUJITH SAGAR. I AM A B.tech SECOND YEAR COMPUTER SCIENCE AND ENGINEERING STUDENT AT NATIONAL INSTITUTE OF TECHNOLOGY DELHI.
Linkedin profile: www.linkedin.com/in/sujith-sagar-gandi-2b3544179
THANK YOU AMAN YADAV AND BINSHUMESH SACHAN FOR RECTIFYING ERRORS :)
Thanks alot to Nikhitha, Bhavani, Sadhana, Kailash varma, Devendhar, Manoj, Rakesh, Karthik, Koushik and all other who are sharing these posts with their Co-geeks. Once again thank you guys.
