剑指offer--面试题21--相关

#include <iostream>

using namespace std;

const int MAX = 100;

class Stack
{
private:
int values[MAX];
int topindex;
int minvalue;
int minSecvalue;

public:
Stack();
virtual ~Stack();

int top() const;
void push(int n);
void pop();
int min();
bool empty() const;
};

Stack::Stack()
{
topindex = 0;
minvalue = INT_MAX;
minSecvalue = INT_MAX;
}

Stack::~Stack()
{
}

bool Stack::empty() const
{
return topindex == 0;
}

int Stack::top() const
{
int toptemp = topindex;
if(!empty())
{
--toptemp;
return values[toptemp];
}
else
{
cerr<<"Stack is empty!"<<endl;
return INT_MAX;
}
}

void Stack::push(int n)
{
if(topindex < MAX)
{
values[topindex++] = n;
if(minvalue > n)
{
minSecvalue = minvalue;
minvalue = n;
}
}
else
cerr<<"Stack is full!"<<endl;
}

void Stack::pop()
{
if(!empty())
{
topindex--;
if(values[topindex] == minvalue)
minvalue = minSecvalue;
}
else
cerr<<"Stack is empty!"<<endl;
}

int Stack::min()
{
if(!empty())
return minvalue;
else
{
cerr<<"Stack is empty!"<<endl;
return INT_MAX;
}
}

#include "stdafx.h"
#include <iostream>
#include "Stack.h"

using namespace std;

int main()
{
Stack st;
for(int i=1; i<=10; i++)
st.push(i);
int top = st.top();
cout<<top<<endl;
int min = st.min();
cout<<min<<endl;
st.pop();
st.pop();
top = st.top();
cout<<top<<endl;
st.push(2);
top = st.top();
cout<<top<<endl;
min = st.min();
cout<<min<<endl;

return 0;
}

//思路：首先，自己之前编写的栈正是作者所说的第二种行不通的；
//此时，若深入想下去，就可能因为需要更多的成员变量而想到再设置一个栈！

//解决本题的关键：想到设置辅助栈，而且通过例子来模拟push，pop和min函数
//          关键中的关键：min函数的操作如何达到O(1)，或者说是辅助栈的入栈与出栈

//默写代码如下：
//利用stl中的stack,并将StackWithMin写成类模板
#include<stack>

template<class T>
class StackWithMin
{
private:
std::stack<T> stmain;
std::stack<T> sthelp;
public:
StackWithMin();
virtual ~StackWithMin();

bool empty() const;
T min() const;
void pop();
void push(const T& n);
T top() const;
size_t size() const;
};

template<class T>
StackWithMin<T>::StackWithMin()
{
}

template<class T>
StackWithMin<T>::~StackWithMin()
{
}

template<class T>
bool StackWithMin<T>::empty() const
{
return stmain.empty();
}

template<class T>
T StackWithMin<T>::top() const
{
return stmain.top();
}

template<class T>
void StackWithMin<T>::push(const T& n)
{
if(sthelp.empty())
{
sthelp.push(n);
stmain.push(n);
}
else
{
stmain.push(n);
T Intosthelp = (n < sthelp.top()) ? n : sthelp.top();
sthelp.push(Intosthelp);
}
}

template<class T>
void StackWithMin<T>::pop()
{
if(!stmain.empty() && !sthelp.empty())
{
stmain.pop();
sthelp.pop();
}
else
std::cout<<"Stack is empty!"<<std::endl;
}

template<class T>
T StackWithMin<T>::min() const
{
return sthelp.top();
}

template<class T>
size_t StackWithMin<T>::size() const
{
return stmain.size();
}