栈是限定尽在表尾进行插入或删除的线性表(先进先出)。对栈来说，表尾称为栈顶，表头称为栈底。

现在以下面的程序说明对栈的基本操作。

#include#include#include

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define STACK_INIT_SIZE 12

#define ADD 2

typedef struct{

int *base;

int *top;

int stacksize;

}Stack;

int InitStack(Stack *S)                      //初始化

{

S->base=(int *)malloc(STACK_INIT_SIZE * sizeof(int));

if(!S->base)

exit(1);

S->top=S->base;

S->stacksize=STACK_INIT_SIZE;

return OK;

}

int Push(Stack *S,int e)                    //入栈

{

if(S->top - S->base >= S->stacksize)

{

S->base = (int *)realloc(S->base,(S->stacksize+ADD)*sizeof(int));

if(!S->base)

exit(1);

S->top=S->base+S->stacksize;

S->stacksize+=ADD;

}

*(S->top)++=e;

return OK;

}

int Pop(Stack *S,int *e)                    //出栈

{

if(S->top==S->base)

return ERROR;

*e=*(--S->top);

return OK;

}

int visit(int c)

{

printf("%d ",c);

return OK;

}

int StackTraverse(Stack S,int (*visit)(int))   //遍历

{

while(S.top>S.base)

visit(*S.base++);

printf("\n");

return OK;

}

int StackEmpty(Stack S)                        //判断栈是否为空

{

if(S.top == S.base)

return TRUE;

else

return FALSE;

}

int DestroyStack(Stack *S)                     //销毁栈

{

free(S->base);

S->base=NULL;

S->top=NULL;

S->stacksize=0;

return OK;

}

int ClearStack(Stack *s)                      //栈置为空

{

s->top = s->base;

return OK;

}

int StackLength(Stack S)                    //栈的深度

{

return (S.top-S.base);

}

int GetTop(Stack S,int *e)                  //获取栈顶元素

{

if(S.top==S.base)

return ERROR;

*e = *(S.top-1);

return OK;

}

int main(void)

{

int j;

Stack s;

int e;

if(InitStack(&s))                                        //新建

for(j=0;j<5;j++)

Push(&s,j);                                          //入栈

printf("栈中元素依次为：");

StackTraverse(s,visit);                                        //第一次遍历

Pop(&s,&e);                                                    //出栈

printf("弹出的栈顶元素 e=%d\n",e);

printf("栈中元素依次为：");

StackTraverse(s,visit);                                        //次遍历

printf("栈空否：%d (1:空 0:否)\n",StackEmpty(s));              //判断栈是否为空

GetTop(s,&e);

printf("栈顶元素 e=%d 栈的长度为%d\n",e,StackLength(s));       //获取栈顶元素，栈的深度

ClearStack(&s);                                                //清空栈

printf("清空栈后，栈空否：%d(1:空 0:否)\n",StackEmpty(s));

DestroyStack(&s);                                             //销毁栈

printf("销毁栈后，s.top=%u s.base=%u s.stacksize=%d\n",s.top,s.base, s.stacksize);

return 0;

}

#include#include#include

#define STACK_SIZE 5

#define OK 1

#define ERROR 0

typedef struct  note

{

int x;

int y;

}Note;

typedef struct

{

Note *base;

Note *top;

int stack_size;

}Stack;

int init_stack(Stack *p)

{

p->base=malloc(STACK_SIZE * sizeof(struct note));

if(!p->base)

exit(1);

p->top=p->base;

p->stack_size=STACK_SIZE;

return OK;

}

int push(Stack *p,Note e)

{

if(p->top - p->base >= p->stack_size)

return ERROR;

else

*(p->top)++=e;

return OK;

}

int Pop(Stack *p,Note *e)                   //出栈

{

if(p->top==p->base)

return ERROR;

*e=*(--p->top);

return OK;

}

int visit(Note c,Note q)

{

if( c.x!=q.x || c.y!=q.y)

return OK;

else

return ERROR;

}

int stack_traverse(Stack p,int (*visit)(Note, Note),Note q)   //遍历查询

{

int flag=1;

while(p.top > p.base)

{

if(0==visit(*p.base++,q))

return ERROR;

}

return OK;

}

int stack_traverse_print(Stack p)   //遍历打印

{

while(p.top>p.base)

{

printf("%d %d\n",p.base->x,p.base->y);

p.base++;

}

return OK;

}

int main()

{

int x=0,y=0,i=0;

int flag=1;

Note q;

Stack p;

init_stack(&p);   //栈出始化

while(flag)

{

printf("请输入 X and Y:");

scanf("%d %d",&x,&y);

q.x=x;

q.y=y;

if(1==stack_traverse(p,visit,q))              //遍历，若栈中已有将加入的数据，则不加入

{

if(0==push(&p,q))                          //出栈

{

printf("Overflow\n");

break;

}

}

else

printf("The Stack already has this element\n");

printf("是否继续增加元素(flag=1):");

scanf("%d",&flag);

}

stack_traverse_print(p);

return 0;

}