1. //later we create a specialstack class ,which inherits from stack class.there we return the smallest
integer
//implementation
#include
#include
using namespace std;
/* A simple stack class named IntStack with push and pop operations */
class IntStack
{
private:
static const int max = 100;
int arr[max];
int top;
public:
//constructor for initialising value of top
IntStack()
{
top = -1;
}
void push(int x);
int pop();
bool isEmpty();
bool isFull();
};
/* Stack's member method to check if the stack is iempty */
bool IntStack::isEmpty()
{
if(top == -1)
return true;
return false;
}
/* Stack's member method to check if the stack is full */
bool IntStack::isFull()
{
if(top == max - 1)

2. return true;
return false;
}
/* Stack's member method push() to insert an element */
void IntStack::push(int x)
{
if(isFull())
{
cout<<"Stack Overflow";
}
top++;
arr[top] = x;
}
/* Stack's member method pop() to remove an element from it */
int IntStack::pop()
{
if(isEmpty())
{
cout<<"Stack Underflow";
abort();
}
int x = arr[top];
top--;
return x;
}
/* A class that supports all the stack operations and one additional operation getMIN() that
returns the minimum element from stack at any time. This class inherits from the stack class and
uses an auxiliarry stack that holds minimum elements */
class SpecialStack: public IntStack
{
IntStack min;
public:
//function declarations
void push(int x);
int pop();
int getMIN();

3. };
/* SpecialStack's member method to insert an element to it. This method
makes sure that the min stack is also updated with appropriate minimum
values */
void SpecialStack::push(int x)
{
if(isEmpty()==true)
{
IntStack::push(x);
min.push(x);
}
else
{
IntStack::push(x);
int y = min.pop();
min.push(y);
/* push only when the incoming element of main stack is smaller
than or equal to top of auxiliary stack */
if( x <= y )
min.push(x);
}
}
/* SpecialStack's member method to remove an element from it. This method
removes top element from min stack also. */
int SpecialStack::pop()
{
int x = IntStack::pop();
int y = min.pop();
/* Push the popped element y back only if it is not equal to x */
if ( y != x )
min.push(y);
return x;
}
/* SpecialStack's member method to get minimum element from it. */
int SpecialStack::getMIN()

4. {
int x = min.pop();
min.push(x);
return x;
}
/* main program to test SpecialStack methods */
//execution starts here
int main()
{
SpecialStack s;
//push 3 elements and get the minimum
s.push(15);
s.push(25);
s.push(33);
cout<
#include
using namespace std;
/* A simple stack class named IntStack with push and pop operations */
class IntStack
{
private:
static const int max = 100;
int arr[max];
int top;
public:
//constructor for initialising value of top
IntStack()
{
top = -1;
}
void push(int x);
int pop();
bool isEmpty();
bool isFull();
};

5. /* Stack's member method to check if the stack is iempty */
bool IntStack::isEmpty()
{
if(top == -1)
return true;
return false;
}
/* Stack's member method to check if the stack is full */
bool IntStack::isFull()
{
if(top == max - 1)
return true;
return false;
}
/* Stack's member method push() to insert an element */
void IntStack::push(int x)
{
if(isFull())
{
cout<<"Stack Overflow";
}
top++;
arr[top] = x;
}
/* Stack's member method pop() to remove an element from it */
int IntStack::pop()
{
if(isEmpty())
{
cout<<"Stack Underflow";
abort();
}
int x = arr[top];
top--;
return x;
}

6. /* A class that supports all the stack operations and one additional operation getMIN() that
returns the minimum element from stack at any time. This class inherits from the stack class and
uses an auxiliarry stack that holds minimum elements */
class SpecialStack: public IntStack
{
IntStack min;
public:
//function declarations
void push(int x);
int pop();
int getMIN();
};
/* SpecialStack's member method to insert an element to it. This method
makes sure that the min stack is also updated with appropriate minimum
values */
void SpecialStack::push(int x)
{
if(isEmpty()==true)
{
IntStack::push(x);
min.push(x);
}
else
{
IntStack::push(x);
int y = min.pop();
min.push(y);
/* push only when the incoming element of main stack is smaller
than or equal to top of auxiliary stack */
if( x <= y )
min.push(x);
}
}
/* SpecialStack's member method to remove an element from it. This method
removes top element from min stack also. */

7. int SpecialStack::pop()
{
int x = IntStack::pop();
int y = min.pop();
/* Push the popped element y back only if it is not equal to x */
if ( y != x )
min.push(y);
return x;
}
/* SpecialStack's member method to get minimum element from it. */
int SpecialStack::getMIN()
{
int x = min.pop();
min.push(x);
return x;
}
/* main program to test SpecialStack methods */
//execution starts here
int main()
{
SpecialStack s;
//push 3 elements and get the minimum
s.push(15);
s.push(25);
s.push(33);
cout<
Solution
//later we create a specialstack class ,which inherits from stack class.there we return the smallest
integer
//implementation
#include
#include
using namespace std;
/* A simple stack class named IntStack with push and pop operations */

8. class IntStack
{
private:
static const int max = 100;
int arr[max];
int top;
public:
//constructor for initialising value of top
IntStack()
{
top = -1;
}
void push(int x);
int pop();
bool isEmpty();
bool isFull();
};
/* Stack's member method to check if the stack is iempty */
bool IntStack::isEmpty()
{
if(top == -1)
return true;
return false;
}
/* Stack's member method to check if the stack is full */
bool IntStack::isFull()
{
if(top == max - 1)
return true;
return false;
}
/* Stack's member method push() to insert an element */
void IntStack::push(int x)
{
if(isFull())
{

9. cout<<"Stack Overflow";
}
top++;
arr[top] = x;
}
/* Stack's member method pop() to remove an element from it */
int IntStack::pop()
{
if(isEmpty())
{
cout<<"Stack Underflow";
abort();
}
int x = arr[top];
top--;
return x;
}
/* A class that supports all the stack operations and one additional operation getMIN() that
returns the minimum element from stack at any time. This class inherits from the stack class and
uses an auxiliarry stack that holds minimum elements */
class SpecialStack: public IntStack
{
IntStack min;
public:
//function declarations
void push(int x);
int pop();
int getMIN();
};
/* SpecialStack's member method to insert an element to it. This method
makes sure that the min stack is also updated with appropriate minimum
values */
void SpecialStack::push(int x)
{
if(isEmpty()==true)
{

10. IntStack::push(x);
min.push(x);
}
else
{
IntStack::push(x);
int y = min.pop();
min.push(y);
/* push only when the incoming element of main stack is smaller
than or equal to top of auxiliary stack */
if( x <= y )
min.push(x);
}
}
/* SpecialStack's member method to remove an element from it. This method
removes top element from min stack also. */
int SpecialStack::pop()
{
int x = IntStack::pop();
int y = min.pop();
/* Push the popped element y back only if it is not equal to x */
if ( y != x )
min.push(y);
return x;
}
/* SpecialStack's member method to get minimum element from it. */
int SpecialStack::getMIN()
{
int x = min.pop();
min.push(x);
return x;
}
/* main program to test SpecialStack methods */
//execution starts here

11. int main()
{
SpecialStack s;
//push 3 elements and get the minimum
s.push(15);
s.push(25);
s.push(33);
cout<
#include
using namespace std;
/* A simple stack class named IntStack with push and pop operations */
class IntStack
{
private:
static const int max = 100;
int arr[max];
int top;
public:
//constructor for initialising value of top
IntStack()
{
top = -1;
}
void push(int x);
int pop();
bool isEmpty();
bool isFull();
};
/* Stack's member method to check if the stack is iempty */
bool IntStack::isEmpty()
{
if(top == -1)
return true;
return false;
}
/* Stack's member method to check if the stack is full */

12. bool IntStack::isFull()
{
if(top == max - 1)
return true;
return false;
}
/* Stack's member method push() to insert an element */
void IntStack::push(int x)
{
if(isFull())
{
cout<<"Stack Overflow";
}
top++;
arr[top] = x;
}
/* Stack's member method pop() to remove an element from it */
int IntStack::pop()
{
if(isEmpty())
{
cout<<"Stack Underflow";
abort();
}
int x = arr[top];
top--;
return x;
}
/* A class that supports all the stack operations and one additional operation getMIN() that
returns the minimum element from stack at any time. This class inherits from the stack class and
uses an auxiliarry stack that holds minimum elements */
class SpecialStack: public IntStack
{
IntStack min;
public:
//function declarations

13. void push(int x);
int pop();
int getMIN();
};
/* SpecialStack's member method to insert an element to it. This method
makes sure that the min stack is also updated with appropriate minimum
values */
void SpecialStack::push(int x)
{
if(isEmpty()==true)
{
IntStack::push(x);
min.push(x);
}
else
{
IntStack::push(x);
int y = min.pop();
min.push(y);
/* push only when the incoming element of main stack is smaller
than or equal to top of auxiliary stack */
if( x <= y )
min.push(x);
}
}
/* SpecialStack's member method to remove an element from it. This method
removes top element from min stack also. */
int SpecialStack::pop()
{
int x = IntStack::pop();
int y = min.pop();
/* Push the popped element y back only if it is not equal to x */
if ( y != x )
min.push(y);
return x;

14. }
/* SpecialStack's member method to get minimum element from it. */
int SpecialStack::getMIN()
{
int x = min.pop();
min.push(x);
return x;
}
/* main program to test SpecialStack methods */
//execution starts here
int main()
{
SpecialStack s;
//push 3 elements and get the minimum
s.push(15);
s.push(25);
s.push(33);
cout<