剑指Offer系列---(23)包含min函数的栈

1.题目描述：

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的min函数。在该栈中，调用min、push及pop的时间复杂度都是O(1)。

2.分析：

实现方法：把每次的最小元素（之前的最小元素和新压入栈的元素两者的较小值）都保存在一个辅助栈中。

3.源代码：

#include <iostream>
using namespace std;

class CStackElement
{
public:
CStackElement(void){}
CStackElement(int data,int min=0)
{
m_nData = data;
m_nMin = min;
}

~CStackElement(void){}

public:
int m_nData;
int m_nMin;
};

class CStack
{
public:
CStack(int maxSize);//普通构造函数，构造一个大小为maxSize的栈
CStack(const CStack &stack);//拷贝构造函数
CStack & operator=(const CStack &stack);//赋值函数
~CStack(void);

void Push(int nPushElement);//向栈中压入一个元素nElement
void Pop();//从栈中弹出一个元素，并返回
int Min();//O(1)的时间返回最小元素值

private:
CStackElement *m_pStackArr;
int m_top;//指向栈顶元素的下一个位置
int m_nMaxSize;
};

//普通构造函数，构造一个大小为maxSize的栈
CStack::CStack(int maxSize)
{
m_top = 0;//指向栈顶元素的下一个位置
m_nMaxSize = maxSize;
m_pStackArr = new CStackElement[m_nMaxSize];
}

//拷贝构造函数
CStack::CStack(const CStack &stack)
{
m_top = stack.m_top;
m_nMaxSize = stack.m_nMaxSize;
m_pStackArr = new CStackElement[m_nMaxSize];
memcpy(m_pStackArr,stack.m_pStackArr,m_nMaxSize);
}

//赋值函数
CStack & CStack::operator=(const CStack &stack)
{
if(this == &stack)//自赋值检查
{
return *this;
}
if(stack.m_top != 0)
{
if(m_nMaxSize <stack.m_nMaxSize)
{
m_nMaxSize = stack.m_nMaxSize;
delete[] m_pStackArr;
m_pStackArr = new CStackElement[m_nMaxSize];
memcpy(m_pStackArr, stack.m_pStackArr, m_nMaxSize);
}
}
return *this;
}

//向栈中压入一个元素nElement
void CStack::Push(int nPushElement)
{
if(m_top == m_nMaxSize)
{
cout<<"栈满!"<<endl;
}
else if(m_top == 0)//栈空
{
m_pStackArr[m_top++].m_nData = nPushElement;
m_pStackArr[m_top++].m_nMin = nPushElement;
cout<<"压入"<<nPushElement<<endl;
}
else
{
if(m_pStackArr[m_top-1].m_nMin > nPushElement)
{
m_pStackArr[m_top].m_nMin = nPushElement;
}
else
{
m_pStackArr[m_top].m_nMin = m_pStackArr[m_top-1].m_nMin;
}
m_pStackArr[m_top++].m_nData = nPushElement;
cout<<"压入"<<nPushElement<<endl;
}
}

//从栈中弹出一个元素并返回
void CStack::Pop()
{
int nPopElement = 0;
if(m_top == 0)
{
nPopElement = -1;
cout<<"栈空!"<<endl;
}
else
{
nPopElement = m_pStackArr[--m_top].m_nData;
cout<<"弹出"<<nPopElement<<endl;
}
}

//O(1)的时间返回最小元素值
int CStack::Min()
{
if(m_top == 0)
{
cout<<"栈空!"<<endl;
return -1;
}
else
{
return m_pStackArr[m_top-1].m_nMin;
}
}

CStack::~CStack(void)
{

}

int main(int argc,char *argv[]){

CStack stack(20);
stack.Push(4);
cout<<"Min:"<<stack.Min()<<endl;

stack.Push(5);
cout<<"Min:"<<stack.Min()<<endl;

stack.Push(2);
cout<<"Min:"<<stack.Min()<<endl;

stack.Pop();
cout<<"Min:"<<stack.Min()<<endl;

stack.Push(3);
cout<<"Min:"<<stack.Min()<<endl;

}

4.运行效果：

压入4
Min:4
压入5
Min:4
压入2
Min:2
弹出2
Min:4
压入3
Min:3
Program ended with exit code: 0