栈的操作

</pre><pre name="code" class="cpp">在数据结构中，栈是限制在表的一端进行插入和删除的线性表。在线性表中允许插入、删除的这一端称为栈顶，栈顶的当前位置是动态变化的，这样我们只能在栈顶对栈进行操作；不允许插入和删除的另一端称为栈底，栈底是固定不变得，当表中没有元素时称为空栈。
对栈的常用操作有：
栈初始化：Init_Stack()  初始条件：栈不存在  操作结果：构造了一个空栈
判断空： Empty_Stack()  若栈空，则返回为1，否则返回0
入栈：   Push_Stack(S,x)    初始条件：栈S已经存在  操作结果：在栈S的顶部插入一个元素x，这样x就、成为新的栈顶元素。
出栈：   Pop_Stack(S,&x)   初始条件：栈S存在且不为空  操作结果：栈S的顶部元素从栈顶删除，保存在变量x中
取栈顶元素： GetTop_Stack(S)  初始条件：栈s存在且不为空  操作结果：返回栈S的栈顶元素，且原栈的结构不会变化
销毁栈：     Destory_Stack(S) 初始条件：栈S已经存在  操作结果： 销毁一个已经存在的栈
栈的存储方式：（1）顺序存储 （2）链式存储
下面我分别介绍这两种的实现：
顺序存储
顺序存储中用int data[STACKSIZE] 来存放所有的入栈元素，栈底的位置可以设置固定在数组的任意一端，栈顶指示实际的栈顶元素位置，它是随着插入和删除是动态变化的，用int top变量来指示栈顶的位置
将data 和 top封装在一个结构中
#define MAXSIZE 100
typedef{
DataType data[STACKSIZE];
int top;
}SeqStack,*PSeqStack；
下面用一个实例介绍栈的一些基本操作(经过测试)：
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define STACKSIZE 100
typedef struct{
int data[STACKSIZE];
int top;
}SeqStack,*PSeqStack;
PSeqStack Init_SeqStack()
{
PSeqStack S;
S=(PSeqStack)malloc(sizeof(SeqStack));
if(S!=NULL)
S->top=-1;
return S;
}

int Empty_SeqStack(PSeqStack S)
{
if(S->top==-1)
return 1;
else return 0;
}

int Push_SeqStack(PSeqStack S,int x)
{
if(S->top==STACKSIZE-1)
return 0;
else{
S->top++;
S->data[S->top]=x;
return 1;
}
}

int Pop_SeqStack(PSeqStack S,int *x)
{
if(Empty_SeqStack(S)==1)
return 0;
else{
*x=S->data[S->top];
S->top--;
return 1;
}
}
int GetTop_SeqStack(PSeqStack S)
{
if(Empty_SeqStack(S)==1){
printf("Empty Stack!\n");
return -1;
}
else
return S->data[S->top];
}
int Destory_SeqStack(PSeqStack *S)
{
if(*S){
free(*S);
*S=NULL;
return 1;
}
return 0;
}
int main()
{
PSeqStack s;
int x=0;
s=Init_SeqStack();
Push_SeqStack(s,1);
Push_SeqStack(s,2);
Push_SeqStack(s,3);
Push_SeqStack(s,4);
printf("Top:%d ",GetTop_SeqStack(s));
Destory_SeqStack(&s);
return 1;
}
链式存储
栈的链式存储一般用单链表来实现，实现代码如下：
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define STACKSIZE 100
typedef struct LinkStack{
int data;
struct LinkStack *next;
}LinkStackNode,*PLinkStackNode;
typedef struct{
PLinkStackNode top;
}LinkStack,*PLinkStack;
PLinkStack Init_LinkStack()
{
PLinkStack s;
s=(PLinkStack)malloc(sizeof(LinkStack));
if(s)
s->top=NULL;
return s;
}

int Empty_LinkStack(PLinkStack S)
{
if(S->top==NULL)
return 1;
else return 0;
}

int Push_LinkStack(PLinkStack S,int x)
{
PLinkStackNode p;
p=(PLinkStackNode)malloc(sizeof(LinkStackNode));
if(p!=NULL){
p->data=x;
p->next=S->top;
S->top=p;
return 1;
}else
return 0;
}

int Pop_LinkStack(PLinkStack S,int *x)
{
PLinkStack p;
if(Empty_LinkStack(S)==1)
return 0;
else{
p=S;
*x=S->top->data;
S->top=S->top->next;
free(p);
return 1;
}
}
int GetTop_LinkStack(PLinkStack S)
{
if(Empty_LinkStack(S)==1){
printf("Empty Stack!\n");
return -1;
}
else
return S->top->data;
}
int Destory_LinkStack(PLinkStack *S)
{
PLinkStackNode p,q;
if(*S){
p=(*S)->top;
while(p){
q=p;
p=p->next;
free(q);
}
free(*S);
}
*S=NULL;
return 1;
}
int main()
{
PLinkStack s;
int x=0;
s=Init_LinkStack();
Push_LinkStack(s,1);
Push_LinkStack(s,2);
Push_LinkStack(s,3);
Push_LinkStack(s,6);
printf("Top:%d ",GetTop_LinkStack(s));
Destory_LinkStack(&s);
return 1;
}

#include "stdafx.h"

#include<cstdio>

#include<cstdlib>

#define OK 1

#define TRUE 1

#define ERROR 0

#define FALSE 0

#define overflow -2

#define STACK_INTT_SIZE 100

#define STACK_INIT_INCREMENT 20

#define Status int

#define ElemType int

typedef struct

{

ElemType *base,*top;

int stackSize;

}SqStack;

/* 栈的操作

Status InitStatck(SqStack &s) 初始化栈

Status DestoryStatck(SqStack &s) 销毁栈

Status ClearStack(SqStack &s) 清除栈

bool StackEmpty(SqStack s) 栈是否为空

int StackLength(SqStack s) 栈的长度

Status GetTop(SqStack s,SElemType &e) 得到栈顶

Status Push(SqStack &s,SElemType e) 压栈

Status Pop(SqStack &s,SElemType &e) 出栈

void DisplayStack(SqStack s); 显示栈内的元素

*/

Status InitStatck(SqStack &s)

{

s.base=(ElemType*)malloc(STACK_INTT_SIZE*(sizeof(ElemType)));

if(!s.base)

return ERROR;

else

s.top=s.base;

s.stackSize=STACK_INTT_SIZE;

}

Status DestoryStatck(SqStack &s)

{

s.top=s.base;

free(s.base);

s.base=NULL;

s.top=NULL;

return OK;

}

bool StackEmpty(SqStack s)

{

if(s.base==s.top)

return TRUE;

else

return FALSE;

}

int StackLength(SqStack s)

{

if(s.base=s.top)

return ERROR;

else

return (s.top-s.base);

}

Status GetTop(SqStack s,ElemType &e)

{

if(StackEmpty(s))

{

printf("This stack is empty.");

return ERROR;

}

else

{

s.top--;

e=*s.top;

return OK;

}

}

Status Push(SqStack &s,ElemType e)

{

if(StackLength(s)==STACK_INTT_SIZE)

{

ElemType*temp=(ElemType*)realloc(s.base,(STACK_INTT_SIZE+STACK_INIT_INCREMENT)*(sizeof(ElemType)));

if(!temp)

return ERROR;

s.base=temp;

s.top=s.base+STACK_INTT_SIZE;

s.stackSize=STACK_INTT_SIZE+STACK_INIT_INCREMENT;

*(s.top++)=e;

return OK;

}

else

{

*s.top=e;

s.top++;

return OK;

}

}

Status Pop(SqStack &s,ElemType &e)

{

if(StackEmpty(s))

{

printf("This stack is empty.");

return ERROR;

}

else

{

e=*(--s.top);

return OK;

}

}

Status ClearStack(SqStack &s)

{

s.top=s.base;

s.stackSize=0;

return OK;

}

void DisplayStack(SqStack s)

{

if(StackEmpty(s))

exit(-1);

while(s.top!=s.base)

printf("%d\n",*(--s.top));

}

int _tmain(int argc, _TCHAR* argv[])

{

SqStack statck;

InitStatck(statck);

for(int i=0;i<5;i++)

{

if(Push(statck,i))

printf("%d is push in this statck success!\n",i);

else

printf("/n/thappen a error\n\t");

}

DisplayStack(statck);//显示栈内的元素

int tem;

printf("now i will print this top of statck !\n");

GetTop(statck,tem);

printf("%d is top of this statck\n",tem);

DestoryStatck(statck);

system("pause");

return 0;

}