顺序栈和链栈的基本操作

SqStack.h

//**********一些预定义常量和类型***********

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;

//**********栈的顺序存储表示***************

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int SElemType;
typedef struct
{
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;

//**********基本操作的函数原型说明**********

Status InitStack(SqStack *S);
//构造一个空栈S
Status DestroyStack(SqStack *S);
//销毁栈S，S不再存在
Status ClearStack(SqStack *S);
//把S置为空栈
Status StackEmpty(SqStack S);
//若栈S为空栈，则返回TRUE,否则返回FALSE
int StackLength(SqStack S);
//返回S的元素个数，即栈的长度
Status GetTop(SqStack S,SElemType *e);
//若栈不空，则用*e返回S的栈顶元素，并返回OK；否则返回ERROR
Status Push(SqStack *S,SElemType e);
//插入e为新的栈顶元素
Status Pop(SqStack *S,SElemType *e);
//若栈不空，则删除S的栈顶元素，用*e返回其值，并返回OK；否则返回ERROE
Status StackTraverse(SqStack S);
//从栈顶到栈底遍历栈

//**********基本操作的算法描述部分************

//初始化
Status InitStack(SqStack *S)
{
S->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S->base) exit(OVERFLOW);
S->top=S->base;
S->stacksize=STACK_INIT_SIZE;
return OK;
}

//销毁
Status DestroyStack(SqStack *S)
{
int i;
for(i=1;i<=S->stacksize;i++)
free(S->base++);
S->base=S->top=NULL;
S->stacksize=0;
return OK;
}

//置空
Status ClearStack(SqStack *S)
{
S->top=S->base;
return OK;
}

//判空
Status StackEmpty(SqStack S)
{
if(S.top==S.base)
return TRUE;
else
return FALSE;
}

//测长度
int StackLength(SqStack S)
{
return S.top-S.base;
}

//取栈顶元素
Status GetTop(SqStack S,SElemType *e)
{
if(S.top==S.base) return ERROR;
*e=*(S.top-1);
return OK;
}

//入栈
Status Push(SqStack *S,SElemType e)
{
if(S->top-S->base>=S->stacksize)
{
//栈满，追加存储空间
S->base=(SElemType *)realloc(S->base,
(S->stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!S->base) exit(OVERFLOW);
S->top=S->base+S->stacksize;
S->stacksize+=STACKINCREMENT;
}
*S->top++=e;
return OK;
}

//出栈
Status Pop(SqStack *S,SElemType *e)
{
if(S->top==S->base) return ERROR;
*e=*--S->top;
return OK;
}

//遍历
Status StackTraverse(SqStack S)
{
if(StackEmpty(S)) printf("此时栈为空栈!\n");
for(S.top--;S.top>S.base;S.top--)
printf("%d ",*S.top);
printf("%d\n",*S.top);
return OK;
}

LinkStack.h

//**********一些预定义常量和类型***********

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;

//**********栈的链式存储表示***************
//没有头结点
typedef int SElemType;

//结点结构
typedef struct StackNode
{
SElemType data;
struct StackNode *next;
}StackNode;

//链栈结构
typedef struct LinkStack
{
struct StackNode *top;
int count;
}LinkStack;

//**********基本操作的函数原型说明**********

Status InitStack(LinkStack *S);
//构造一个空栈S
Status DestroyStack(LinkStack *S);
//销毁栈S，S不再存在
Status ClearStack(LinkStack *S);
//把S置为空栈
Status StackEmpty(LinkStack S);
//若栈S为空栈，则返回TRUE,否则返回FALSE
int StackLength(LinkStack S);
//返回S的元素个数，即栈的长度
Status GetTop(LinkStack S,SElemType *e);
//若栈不空，则用*e返回S的栈顶元素，并返回OK；否则返回ERROR
Status Push(LinkStack *S,SElemType e);
//插入e为新的栈顶元素
Status Pop(LinkStack *S,SElemType *e);
//若栈不空，则删除S的栈顶元素，用*e返回其值，并返回OK；否则返回ERROE
Status StackTraverse(LinkStack S);
//从栈顶到栈底遍历栈

//**********基本操作的算法描述部分************

//初始化
Status InitStack(LinkStack *S)
{
S->top=NULL;
S->count=0;
return OK;
}

//销毁
Status DestroyStack(LinkStack *S)
{
StackNode *p=S->top;
for(S->count;S->count>0;S->count--)
{
S->top=p->next;
free(p);
p=S->top;
}
S->count=0;
return OK;
}

//置空
Status ClearStack(LinkStack *S)
{
S->top=NULL;
S->count=0;
return OK;
}

//判空
Status StackEmpty(LinkStack S)
{
if(!S.count)
return TRUE;
else
return ERROR;
}

//测长度
int StackLength(LinkStack S)
{
return S.count;
}

//取栈顶元素
Status GetTop(LinkStack S,SElemType *e)
{
if(!S.count) return ERROR;
*e=S.top->data;
return OK;
}

//入栈
Status Push(LinkStack *S,SElemType e)
{
StackNode *p=(StackNode *)malloc(sizeof(StackNode));
p->data=e;
p->next=S->top;
S->top=p;
S->count++;
return OK;
}

//出栈
Status Pop(LinkStack *S,SElemType *e)
{
if(!S->count)
return ERROR;
StackNode *p=S->top;
*e=S->top->data;
S->top=p->next;
free(p);
S->count--;
return OK;
}

//遍历
Status StackTraverse(LinkStack S)
{
while(S.top)
{
printf("%d ",S.top->data);
S.top=S.top->next;
}
return OK;
}

主函数文件

#include<stdio.h>
#include<stdlib.h>
#include"SqStack.h"
#include"LinkStack.h"
int main()
{
SqStack Q;//LinkStack Q;
SElemType x,y;
int number;
do
{
printf("\n\n\t主菜单\n\n");
printf("%3c1%4c初始化\n",' ',' ');
printf("%3c2%4c销毁\n",' ',' ');
printf("%3c3%4c置空\n",' ',' ');
printf("%3c4%4c判空\n",' ',' ');
printf("%3c5%4c测长度\n",' ',' ');
printf("%3c6%4c取栈顶元素\n",' ',' ');
printf("%3c7%4c入栈\n",' ',' ');
printf("%3c8%4c出栈\n",' ',' ');
printf("%3c9%4c遍历\n\n",' ',' ');
printf("请输入您的选择（1-8）：");
scanf("%d",&number);//第一次输入必须为1，即必须初始化

switch(number)
{
case 1:
{
InitStack(&Q);
printf("栈已初始化，此时栈为空栈！\n");break;
}
case 2:
{
DestroyStack(&Q);
printf("栈已销毁，此时栈不存在！\n");break;
}
case 3:
{
ClearStack(&Q);
printf("栈已被置空，此时栈为空栈！\n");break;
}
case 4:
{
if(StackEmpty(Q))
{
printf("此时栈为空栈！\n");break;
}
else
{
printf("此时栈不是空栈！\n");break;
}
}
case 5:
{
printf("栈的长度为%d\n",StackLength(Q));break;
}
case 6:
{
GetTop(Q,&x);
printf("此时栈顶元素为：%d\n",x);break;
}
case 7:
{
printf("请输入入栈元素：");
scanf("%d",&y);
Push(&Q,y);
printf("此时从栈顶到栈底遍历栈，得到如下序列：\n");
StackTraverse(Q);break;
}
case 8:
{
Pop(&Q,&x);
printf("出栈元素为：%d\n",x);
printf("此时从栈顶到栈底遍历栈，得到如下序列：\n");
StackTraverse(Q);break;
}
case 9:
{
printf("此时从栈顶到栈底遍历栈，得到如下序列：\n");
StackTraverse(Q);break;
}
}
}while(number<=9);
return 0;
}