顺序栈的操作实现_C语言

实现代码

#include<stdio.h>
#include<stdlib.h>

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define TRUE 1
#define FALSE 0

typedef int SElemType;
typedef int Status;
typedef struct
{
SElemType *base; //栈底指针
SElemType *top; //栈顶指针
int stacksize; //栈已分配的空间大小
}SqStack; //动态分配

void InitStack(SqStack &S) //初始化栈
{
S.base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S.base)
{
printf("ERROR!");
exit(0);
}
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
}

SElemType GetTop(SqStack &S) //读取栈顶元素
{
SElemType e;
if(S.top == S.base) //栈为空
{
printf("ERROR!");
exit(0);
}
e = *(S.top - 1);
return e;
}

void Push(SqStack &S, SElemType &e) //入栈
{
if(S.top - S.base >= S.stacksize) //栈满
{
S.base = (SElemType *)realloc(S.base, (STACK_INIT_SIZE + STACKINCREMENT)*sizeof(SElemType));
if(!S.base)
{
printf("ERROR!");
exit(0);
}
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
*S.top = e;
S.top ++; //*S.top ++ = e
}

SElemType Pop(SqStack &S) //出栈
{
SElemType e;
if(S.base == S.top) //栈空
{
printf("ERROR");
exit(0);
}
--S.top;
e = *S.top; //e = *(--S.top)
return e;
}

void PrintStack(SqStack &S)
{

SElemType *p = S.base;
if(S.base == S.top)
{
printf("Empty");
exit(0);
}
while(p != S.top)
{
printf("%d ", *p);
p ++;
}
}

int main()
{
SqStack S;
InitStack(S);
SElemType e;
int i,n;
char c;
printf("请输入入栈元素个数： ");
scanf("%d", &n);
printf("请输入入栈元素： ");
for(i = 0; i < n; i ++)
{
scanf("%d", &e);
Push(S,e);
}
printf("入后，栈为： ");
PrintStack(S);
printf("\n栈顶元素为：%d\n", Pop(S));
printf("出栈后，栈为： ");
PrintStack(S);
return 0;
}

运行结果

第二次写这个代码2333

#include <stdio.h>
#include <stdlib.h>
#include<math.h> //在math.h中已定义OVERFLOW的值为3

#define STACK_INIT_SIZE 10 //存储空间初始分配量
#define STACKINCREMENT 2 //存储空间分配增量

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0

typedef int Status;
typedef int SElemType;

typedef struct
{
SElemType *base; //在栈构造之前和销毁之后，base的值为NULL
SElemType *top;
int stacksize; //当前已分配的存储空间，以元素为单位
}SqStack; //顺序栈

Status InitStack(SqStack &S)
{
if(!(S.base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType))))
exit(OVERFLOW);
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
return OK;
}

Status DestoryStack(SqStack &S)
{
free(S.base);
S.base = NULL;
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) //返回栈顶元素，若栈为空，返回ERROR
{
if(S.top > S.base)
{
e = *(S.top - 1);
return OK;
}
else
return ERROR;
}

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;
S.top ++;
return OK;
}

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

void Print(SqStack S)
{
SElemType *p = S.base;
while(p != S.top)
printf("%d ",*p ++);
printf("\n");
}
/*Status StackTraverse(SqStack S, SqStack(*vist)(SElemType)) //从栈底到栈顶依次对每个元素调用函数visit()
{
while(S.top > S.base)
visit(*S.base ++);
printf("\n");
return OK;
}*/

Status visit(SElemType c)
{
printf("%d", c);
return OK;
}

int main()
{
int j;
SqStack S;
SElemType e;
if(InitStack(S) == OK)
{
for(j = 1; j <= 12; j++)
Push(S,j);
}
printf("栈中元素依次为： ");
Print(S);
Pop(S, e);
printf("弹出的栈顶元素为：%d\n",e);
printf("栈空否：%d(1：空 0：非空)\n", StackEmpty(S));
GetTop(S,e);
printf("栈顶元素：%d，栈的长度为：%d\n", e, StackLength(S));
ClearStack(S);
printf("清空栈后，栈空否 %d (空 1 非空 0)\n", StackEmpty(S));
DestoryStack(S);
printf("销毁栈后，S.top = %d, S.base = %d\n", S.top, S.base);
printf("NULL = %d", NULL);
return 0;
}

运行结果

个人理解

顺序栈采用顺序存储结构，实质是一个有约束条件的顺序表，先入后出。

收获感悟

传值与传址的问题

一开始程序所有的函数参数都没有加&符号，运行一半不通过，经过请教丰一帆，以及搜索，了解到这涉及传值与传址的问题，代码部分暂时使用了C++中的&，还未深入研究为什么，remain to be settled.

函数模块化

简明，易维护。