数据结构C语言—线性表【栈】静态顺序栈（定义结构体变量实现）
SqStackStatic.h
#define MAXSIZE 100
#define NOINIT -1
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE 1
#define OVERFLOW 1
typedef int Status;
typedef int DataType;
typedef int *Pt;
typedef struct SqStack
{
DataType base;//指向栈底的指针（以数组元素下表作为指针）
DataType top;//指向栈顶元素的下一个顺序位置（以数组元素下表作为指针）
DataType data[MAXSIZE];//栈数组元素个数，为定值分配空间
}SqStack,*SqStackPonit;
Status InitStack(SqStackPonit S);//初始化一个空静态顺序栈S，成功返回OK，否则返回ERROR
Status ClearStack(SqStackPonit S);//清空静态顺序栈S，返回OK；静态顺序栈S未初始化（NOINIT）;栈顶指针等于栈底指针——空状态标志
//Status DestoryStack(SqStackPonit S);//销毁一个栈S
Status IsEmptyStack(SqStackPonit S);//判断一个栈是否为空，是空（TRUE），不是空（FALSE）;静态顺序栈S未初始化（NOINIT）
DataType StackLength(SqStackPonit S);//返回栈S的元素个数，即栈长度，静态顺序栈S未初始化（NOINIT）
Status GetTop_Stack(SqStackPonit S,Pt e);//若栈不空，用*e返回栈S顶的元素，返回OK；若栈空（ERROR）；静态顺序栈S未初始化（NOINIT）
Status Push_Stack(SqStackPonit S,DataType e);//若栈不满，将e入栈，返回OK；栈满，返回ERROR；静态顺序栈S未初始化（NOINIT）
Status Pop_Stack(SqStackPonit S,Pt e);//若栈不空，将栈顶元素出栈，即删除栈顶元素，用*e返回其值，返回OK；若栈空（ERROR）；静态顺序栈S未初始化（NOINIT）
Status StackTraverse(SqStackPonit S,Status (*Visit)(SqStackPonit S,DataType p));//栈不空，对每个元素调用Visist()，返回OK；若栈空（ERROR）；静态顺序栈S未初始化（NOINIT）
Status Visit(SqStackPonit S,DataType p);//遍历调用函数
SqStackStatic.c
#include <stdio.h>
#include <stdlib.h>
#include "SqStackStatic.h"
Status Visit(SqStackPonit S,DataType p)//遍历调用函数
{
if(p==0)
{
printf("栈底指针----->%d:%d\n",p,(S->data)[p]);
}
else
{
printf(" %d:%d\n",p,(S->data)[p]);
}
return OK;
}
Status InitStack(SqStackPonit S)//初始化一个空静态顺序栈S，返回OK
{
puts("==========开始【初始化栈】操作！==========");
S->base=0;//栈底固定的指向数组0位置
S->top=0;//S->top等于S->base等于0，即空栈标志
for(int i=0;i<MAXSIZE;i++)//给静态数组栈的每个元素赋初始值
{
(S->data)[i]=0;
}
puts("==========完成【初始化栈】操作！==========");
return OK;
}
Status ClearStack(SqStackPonit S)//清空静态顺序栈S，返回OK；静态顺序栈S未初始化（NOINIT）;栈顶指针等于栈底指针——空状态标志
{
if(S->top>MAXSIZE+1 || S->top<0 || S->base>MAXSIZE+1 || S->base<0)
{
puts("\n==========静态顺序栈S【未初始化】不能执行【清空】操作==========");
return NOINIT;
}
puts("\n==========开始【清空】静态顺序栈S！==========");
S->top=S->base=0;//空栈状态标志
puts("==========【清空】静态顺序栈S完成！==========");
return OK;
}
//Status DestoryStack(SqStackPonit S);//销毁一个栈S
Status IsEmptyStack(SqStackPonit S)//判断一个栈是否为空，是空（TRUE），不是空（FALSE）;静态顺序栈S未初始化（NOINIT）
{
if(S->top>MAXSIZE+1 || S->top<0 || S->base>MAXSIZE+1 || S->base<0)
{
puts("\n==========静态顺序栈S【未初始化】不能执行【判空】操作==========");
return NOINIT;
}
if(S->top==S->base)
{
return TRUE;
}
else
{
return FALSE;
}
}
DataType StackLength(SqStackPonit S)//返回栈S的元素个数，即栈长度，静态顺序栈S未初始化（NOINIT）
{
if(S->top>MAXSIZE+1 || S->top<0 || S->base>MAXSIZE+1 || S->base<0)
{
puts("\n==========静态顺序栈S【未初始化】不能执行【求长】操作==========");
return NOINIT;
}
return S->top-S->base;
}
Status GetTop_Stack(SqStackPonit S,Pt e)//若栈不空，用*e返回栈S顶的元素，返回OK；若栈空（ERROR）；静态顺序栈S未初始化（NOINIT）
{
if(S->top>MAXSIZE+1 || S->top<0 || S->base>MAXSIZE+1 || S->base<0)
{
*e=-6699;
puts("\n==========静态顺序栈S【未初始化】不能执行【获顶】操作==========");
return NOINIT;
}
if(S->top==S->base && S->base==0)
{
*e=-6699;
puts("\n==========静态顺序栈S【是空栈】不能执行【获顶】操作==========");
return ERROR;
}
else
{
*e=S->data[S->top-1];
printf("当前静态顺序栈S中，栈顶元素是：%d\n",*e);
return OK;
}
}
Status Push_Stack(SqStackPonit S,DataType e)//若栈不满，将e入栈，返回OK；栈满，返回ERROR；静态顺序栈S未初始化（NOINIT）
{
if(S->top>MAXSIZE+1 || S->top<0 || S->base>MAXSIZE+1 || S->base<0)
{
puts("\n==========静态顺序栈S【未初始化】不能执行【入栈】操作==========");
return NOINIT;
}
if(StackLength(S)==MAXSIZE)
{
puts("\n==========静态顺序栈S【栈满】不能执行【入栈】操作==========\n");
return ERROR;
}
else
{
(S->data)[(S->top)++]=e;
return OK;
}
}
Status Pop_Stack(SqStackPonit S,Pt e)//若栈不空，将栈顶元素出栈，即删除栈顶元素，用*e返回其值，返回OK；若栈空（ERROR）；静态顺序栈S未初始化（NOINIT）
{
if(S->top>MAXSIZE+1 || S->top<0 || S->base>MAXSIZE+1 || S->base<0)
{
*e=-6699;
puts("\n==========静态顺序栈S【未初始化】不能执行【出栈】操作==========");
return NOINIT;
}
if(S->top==S->base && S->base==0)
{
*e=-6699;
puts("\n==========静态顺序栈S【是空栈】不能执行【出栈】操作==========");
return ERROR;
}
else
{
*e=(S->data)[--(S->top)];
return OK;
}
}
Status StackTraverse(SqStackPonit S,Status (*Visit)(SqStackPonit S,DataType p))//栈不空，对每个元素调用Visist()，返回OK；若栈空（ERROR）；静态顺序栈S未初始化（NOINIT）
{
if(S->top>MAXSIZE+1 || S->top<0 || S->base>MAXSIZE+1 || S->base<0)
{
puts("\n==========静态顺序栈S【未初始化】不能执行【遍历】操作==========");
return NOINIT;
}
if(S->base==S->top && S->base==0)
{
puts("\n==========开始遍历检查静态顺序栈S==========");
printf("栈顶指针----->0：空<-----栈底指针");
puts("\n==========遍历检查静态顺序栈S完成==========");
return ERROR;
}
else
{
puts("==========开始遍历检查静态顺序栈S==========");
DataType p;
printf("栈顶指针----->%d\n",StackLength(S));
for(p=S->top-1;p!=-1;p--)
{
// printf("p=%d\n",p);
Visit(S,p);
}
puts("==========遍历检查静态顺序栈S完成==========");
return OK;
}
}
main.c
#include <stdio.h>
#include <stdlib.h>
#include "SqStackStatic.h"
/* 线性表——顺序栈（静态分配）【自编代码】 */
int main()
{
SqStack S;
DataType e;
IsEmptyStack(&S);
ClearStack(&S);
StackLength(&S);
Push_Stack(&S,10);
GetTop_Stack(&S,&e);
Pop_Stack(&S,&e);
InitStack(&S);
puts("请按先后顺序，输入要入栈的元素（空格分隔，f结束）：");
while(1)
{
int n,k;
k=scanf("%d",&n);
if(k==0)
{
break;
}
Push_Stack(&S,n);
}
StackTraverse(&S,Visit);
if(IsEmptyStack(&S))
{
puts("\n==========静态顺序栈S【是空栈】==========");
}
else
{
puts("\n==========静态顺序栈S【不是空栈】==========");
}
if(StackLength(&S)!=NOINIT)
{
printf("当前动态顺序栈S中已存在元素个数是：%d!\n",StackLength(&S));
}
GetTop_Stack(&S,&e);
Pop_Stack(&S,&e);
if(e!=-6699)
{
printf("已经弹出栈顶元素：%d!\n",e);
}
StackTraverse(&S,Visit);
ClearStack(&S);
GetTop_Stack(&S,&e);
StackTraverse(&S,Visit);
if(IsEmptyStack(&S))
{
puts("\n==========静态顺序栈S【是空栈】==========");
}
else
{
puts("\n==========静态顺序栈S【不是空栈】==========");
}
fflush(stdin);
puts("请按先后顺序，输入要入栈的元素（空格分隔，f结束）：");
while(1)
{
int n,k;
k=scanf("%d",&n);
if(k==0)
{
break;
}
Push_Stack(&S,n);
}
StackTraverse(&S,Visit);
ClearStack(&S);
StackTraverse(&S,Visit);
return 0;
}
运行结果示例
------------------------------------------------------第六次发文章有点激动啊！-----------------------------------------------------
-----------------------------------------------------【数据结构代码自编练习】------------------------------------------------------
----------------------------------------------------------------【TDTX】-----------------------------------------------------------------
