栈

栈

栈的定义与特点

栈的表示操作和实现

栈的类型定义

ADT Stack{

	数据对象：D={ai|ai∈Element，i=1,2,...,n,n>=0)
	数据关系：R={<ai-1,ai>|ai-1,ai∈D,i=2,...,n}
			 约定an为栈顶，ai为栈底。
	基本操作：
	InitStack（&S）
	构造一个空栈
	DestroyStack（&S）
	初始条件：栈S以存在
	造作结果：栈S被销毁
	ClearStack（&S）
	初始条件：栈S以存在
	造作结果：将S清为空栈
	StackEmpty（&S）
	初始条件：栈S以存在
	造作结果：若S为空栈，返回true，否则返回false
	StackLength（S）
	初始条件：栈S以存在
	造作结果：返回S的元素个数，即栈的长度
	GetTop（S）
	初始条件：栈S以存在且非空
	造作结果：返回S的栈顶元素，不修改栈顶指针
	Push（&S，e）
	初始条件：栈S以存在且非空
	造作结果：插入元素e为新的栈顶元素
	Pop（&S，e）
	初始条件：栈S以存在且非空
	造作结果：删除S的栈顶元素，并用e返回其值
	StackTraverse（S）
	初始条件：栈S以存在且非空
	造作结果：从栈顶到栈底依次对S的每个元素进行访问
	
}ADT Stack
           

顺序栈的表示和实现

储存结构

#define MAXSIZE 100
typedef struct{
	SElemType *base;//栈底指针
	SElemType *top;//栈顶指针
	int stacksize;//栈可用的最大容量
}SqStack;
           

初始化

Status InitStack(SqStack &S){
	S.base = new SElemType[MAXSIZE];
	if(!S.base)
		return ERROR;	
	S.base = S.top;
	S.stacksieze = MAXSIZE;
	return OK;
}
           

销毁

Status DestroyStack(SqStack &S){
	if(S.base){
		delete S.base;
		S.stacksize = 0;
		S.base = S.top = NULL;
	}
	return OK;
}
           

清空

Status ClearStack(&S){
	if(S.base == NULL) {
		cout<<"顺序栈不存在！"<<endl;
		return FALSE;
	} else {
		while(S.top != S.base) {
			*(S.top)  = 0;
			S.top--;
		}
		*(S.base) = 0;
		cout<<"清空成功！"<<endl;
		return OK;
	}
}
           

判空

bool StackEmpty(SqStack S){
	if(S.base==S.top)
		return true;
	else
		return false;
}
           

求栈长（栈中元素的个数）

int StackLength(SqStack S){
	return S.top - S.base;
}

           

取栈顶元素

SElemType Gettop(SqStack S){
	if(S.top != S.base)
		return  *(S.top-1);
}
           

入栈

Status Push(SqStack &S,SElemType e){
	if((S.top - S.base) == MAXSIZE )
		return ERROR;
	*S.top++ = e;
	return OK;
}
           

出栈

Status Pop(SqStack &S,SElemType &e){
	if(S.base == S.top)
		return ERROR;
	e = *S.top--;
	return OK;
}
           

遍历

Status StackTraverse(SqStack S){
	SqStack *p;
	p = S.base;
	whlie(p != S.top ){
		p++;
	}
	return OK;
}
           

链式栈的表示和实现

typedef struct StackNode{
	SElemType data;
	struct StackNode *next;
}StackNode,*LinkStack;
           

Status InitStack(LinkStack &S){
	S = NULL;
	return OK;
}
           

Status DestroyStack(LinkStack &S){
		if(S == NULL)
			return ERROR;
		StackNode *p;
    	while(S!= NULL)
   		 {   
       	 	p = S;
       	 	S = S->next;
       	 	delete p;
    	}   
    	return OK;
}
           

Status ClearStack(LinkStack &S){
	if(S == NULL)
		return ERROR;
	StackNode *p;
    while(*S){   
       	p = S;
       	S = S->next;
       	delete p;
    }
    *S = NULL; 
    return OK;

}
           

bool StackEmpty(&S){
	if(S == NULL)
		return true;
	else
		return false;
}
           

int StackLength(LinkStack S){
	int i = 0;
	whlie(S != NULL){
		S = S->next;
		i++;
	}
	return i;
}

           

SElemType Gettop(LinkStack S){
	if(S)
		return S->data;
}
           

Status Push(LinkStack &S,SElemType e){
	StackNode *p = new StackNode;
	p->data = e;
	p->next = S;
	S = p;
	return OK;
}
           

Status Pop(LinkStack &S,SElemType &e){
	if(S == NULL)
		return ERROR;
	e = S->data;
	StackNode *p;
	p = S;
	S = S->next;
	delete p;
	return OK;
}
           

Status StackTraverse(LinkStack S){
	while(S != NULL){
		S=S->next;
	}
	return OK;
}