栈的基本操作

#include<iostream> 
using namespace std;

#define STACK_INIT_SIZE 5
#define STACKINCREMENT 10
#define ok 1;
#define error 0;

typedef int SElemType;
typedef int Status;
typedef struct{
	SElemType *top;
	SElemType *base;
	int stacksize;
}SqStack;

class SqStackOperation
{
public:
	//构造一个空栈S
	Status InitStack(SqStack &S);
	//销毁栈S,S不再存在
	Status DestroyStack(SqStack &S);
	//把S置为空栈
	Status ClearStack(SqStack &S);
	//若栈S为空，则返回true，否则返回false
	Status StackEmpty(SqStack S);
	//返回S的元素个数，即栈的程度
	int StackLength(SqStack S);
	//若栈不空，则用e返回S的栈顶元素，并返回ok；否则返回error
	Status GetTop(SqStack S,SElemType &e);
	//插入元素e为新的栈顶元素
	Status Push(SqStack &S,SqStack &SS,SElemType e);
	//若栈不空，则删除S的栈顶元素，用e返回其值，并返回ok，否则返回error
	Status Pop(SqStack &S,SElemType &e);
	//从栈底到栈顶依次对栈中每个元素调用visit（）。一旦visit（）失败，则操作失败
	Status StackTraversal(SqStack S,Status(*visit)(SElemType));
};//SqStackoperation

Status SqStackOperation::InitStack(SqStack &S)
{
	S.base=new SElemType[STACK_INIT_SIZE];//分配栈的初始空间
	if(!S.base)
		exit(-1);
	S.top=S.base;
	S.stacksize=STACK_INIT_SIZE;
	return ok;
}//InitStack

Status SqStackOperation::DestroyStack(SqStack &S)
{
	delete S.base;
	S.stacksize=0;
	S.base=NULL;
	return ok;
}//DestroyStack

Status SqStackOperation::ClearStack(SqStack &S)
{
	/*while(S.top!=S.base)
	{
		S.top--;
	}//while*/
	S.top=S.base;
	return ok;
}//ClearStack

Status SqStackOperation::StackEmpty(SqStack S)
{
	if(S.base==S.top&&S.base!=NULL)//不为空栈且栈存在
		return true;
	else
		return false;
}//StackEmpty

int SqStackOperation::StackLength(SqStack S)
{
	//return((S.top-S.base)/sizeof(SElemType));//栈顶与栈底地址之差再除以一个元素所需地址空间的大小
	return (S.top-S.base);//此时返回的S.top-S.base是int类型与SElemType相同，而不是内存空间的地址值相减
}//StackLength

Status SqStackOperation::GetTop(SqStack S,SElemType &e)
{
	if(S.top==S.base)
		return error;
	e=*(S.top-1);
	return ok;
}//GetTop

Status SqStackOperation::Push(SqStack &S,SqStack &SS,SElemType e)
{
	SElemType m;
	if(S.stacksize<=S.top-S.base)//栈满
	{
		//将栈S中从栈顶到栈底的数据元素（例如5,4,3,2,1）压入到栈SS中，则栈SS从栈底到栈顶元素依次为（5,4,3,2,1）
		while(S.top!=S.base)
		{
			Pop(S,m);
			*SS.top++=m;
		}//while
		delete S.base;
		S.base=new SElemType[S.stacksize+STACKINCREMENT];
		S.top=S.base;
		S.stacksize+=STACKINCREMENT;
		//再将栈SS中的元素复制到新开辟内存的栈S中，恢复栈顶到栈底元素依次为（5,4,3,2,1）的状态
		while(SS.top!=SS.base)
		{
			Pop(SS,m);
			*S.top++=m;
		}//while1
		delete SS.base;
		SS.base=new SElemType[S.stacksize+STACKINCREMENT];
		SS.top=SS.base;
		SS.stacksize+=STACKINCREMENT;
	}//if
	*S.top++=e;
	//*SS.top++=e;
	return ok;
}//Push

Status SqStackOperation::Pop(SqStack &S,SElemType &e)
{
	if(S.top==S.base)
		return error;
	e=*--S.top;
	return ok;
}//Pop

Status visit(SElemType e)
{
	cout<<e<<endl;
	return ok;
}//visit
Status SqStackOperation::StackTraversal(SqStack S,Status (*visit)(SElemType))
{
	SElemType e;
	while(S.top!=S.base)
	{
		Pop(S,e);
		visit(e);
	}//while
	return ok;
}//StackTraversal

void main()
{
	SElemType e,*pt=NULL;
	SqStack S,SS;
	SqStackOperation SOP;
	
	SOP.InitStack(S);
	SOP.InitStack(SS);
	for(int i=1;i<=10;i++)
	{	
		cin>>e;
		SOP.Push(S,SS,e);
	}//for

	cout<<"\n"<<"销毁栈SS："<<SOP.DestroyStack(SS)<<endl;
	cout<<"栈S中从栈顶到栈底元素依次为："<<endl;
	Status (*vis)(SElemType e);
	vis=visit;
	SOP.StackTraversal(S,vis);
	
	cout<<"S栈中数据元素的个数："<<SOP.StackLength(S)<<endl;

	for(int i=1;i<=3;i++)//从栈中弹出3个元素
		SOP.Pop(S,e);
	SOP.StackTraversal(S,vis);
	cout<<"从栈S中弹出3个元素，栈中剩余数据元素的个数："<<SOP.StackLength(S)<<endl;

	SOP.GetTop(S,e);
	cout<<"栈顶元素："<<e<<endl;

	cout<<"判断栈是否为空："<<SOP.StackEmpty(S)<<endl;

	cout<<"将栈清空并销毁："<<SOP.ClearStack(S)<<" "<<SOP.DestroyStack(S)<<endl;
	
}//main