顺序栈定义（概念）
采用顺序存储的栈称为顺序栈，它采用一组地址连续的存储单元存放自栈底到栈顶的数据元素，同时设定一个指针（top）指向当前栈顶元素的位置。通常采用数组来实现。
特点
先进后出，后进先出。
栈的判空条件和判满条件根据实际是指有所不同，这里是top= - 1较方便。
结构体：
空间存储栈中元素。
指针域实际表示数组下标。
typedef struct
{
DataType *data; /* 堆空间 */
int maxsize;
int top; /* 栈顶指针 */
}SeqStack;
初始化
int init(SeqStack *S, int MaxSize)
{
/*申请内存空间*/
S->data = (DataType*)malloc(sizeof(DataType)*MaxSize);
if(!S->data)
{
printf("内存申请错误，初始化失败！[10001]\n");
return 10001;
}
S->maxsize = MaxSize;
S->top = -1;
return 0;
}进栈
参数校验
栈满不能继续进栈
int push(SeqStack *S, DataType x)
{
/*是否满？*/
if(full(S))
{
printf("栈已满！10002\n");
return 10002;
}
S->top++; /*移动指针*/
S->data[S->top] = x;/*放入数据*/
return 0; /*OK*/
}
出栈
栈空不能出栈
int pop(SeqStack *S, DataType *x)
{
/*是否空？*/
if(empty(S))
{
printf("栈为空！10003\n");
return 10003;
}
*x = S->data[S->top]; /*栈顶元素赋值给x*/
S->top--; /*移动栈顶指针*/
return 0;
}
获取长度
即使空栈top= - 1，最后也会返回0.
int length(SeqStack *S)
{
return (S->top+1);
}清空栈内元素
指针指向 - 1即可。
void Clear(SeqStack *S)
{
S->top=-1;
printf("栈已被清空");
}打印
遍历栈内元素
void show(SeqStack *S)
{
int i;
for(i=S->top;i>=0;--i)
{
printf("%d\n",S->data[i]);
}
printf("\n");
}栈是否为空
int empty(SeqStack *S)
{
return (S->top == -1)?1:0;
}
是否为满
int full(SeqStack *S)
{
return (S->top == S->maxsize - 1)?1:0;
}
栈顶元素
int get_top(SeqStack *S, DataType *x)
{
/*是否空？*/
if(empty(S))
{
printf("栈为空！10003\n");
return 10003;
}
*x = S->data[S->top]; /*栈顶元素赋值给x*/
return 0;
}
结果
初始化
入栈
出栈
栈长度
打印
清空
栈是否为空
栈是否满
栈顶元素输出
应用截图
完整结果
代码
main.c
#include <stdio.h>
#include <string.h>
#include "seqstack.h"
/*十进制转换为二进制*/
int d_to_b(int d);
/*后缀表达式计算*/
int expression();
int main(int argc, char* argv[])
{
SeqStack S;
int cmd;
int d;
DataType x;
int maxsize;
char yn;
do
{
printf("---------顺序栈演示程序-----------\n");
printf(" 1. 初始化\n");
printf(" 2. 入栈\n");
printf(" 3. 出栈\n");
printf(" 4. 栈的长度\n");
printf(" 5. 清空栈\n");
printf(" 6. 打印栈\n");
printf(" 7. 帮助\n");
printf(" 8. 栈的应用\n");
printf(" 9. 栈是否空\n");
printf(" 99. 栈是否满\n");
printf(" 999. 栈顶元素\n");
printf("请选择（0退出)：");
scanf("%d", &cmd);
switch(cmd)
{
case 9:
if(empty(&S) == 0){
printf("非空\n");
}else
printf("空 \n");
break;
case 99:
if(full(&S) == 0){
printf("未满\n");
}else
printf("满 \n");
break;
case 999:
get_top(&S,&x);
printf("栈顶元素：%d\n",x);
break;
case 1:
printf("请输入栈的最大存储空间(MaxSize)：");
scanf("%d", &maxsize);
if(!init(&S, maxsize))
{
printf("栈已初始化！\n");
}
break;
case 2:
printf("请输入入栈元素：x=");
scanf("%d", &x);
if(!push(&S, x))
{
printf("元素【%d】已入栈！\n", x);
}
break;
case 3:
printf("确定要出栈（出栈后数据不可恢复,y|n,n）？");
flushall();
scanf("%c", &yn);
if(yn == 'y' || yn == 'Y')
{
if(!pop(&S, &x))
{
printf("栈顶元素【%d】已出栈！\n", x);
}
}
break;
case 4:
printf("栈的长度为：%d\n",length(&S));
break;
case 5:
Clear(&S);
printf("\n");
break;
case 6:
show(&S);
break;
case 7:
printf("本程序由sc于季老师设计上修改完成");
break;
case 8:
do
{
printf("----------8.栈的应用------------\n");
printf(" 1. 十进制转换为二进制\n");
printf(" 2. 后缀表达式计算\n");
printf(" 0. 返回\n");
printf("请选择：");
scanf("%d", &cmd);
if(cmd == 1)
{
printf("请输入一个十进制数：");
scanf("%d", &d);
printf("二进制为：");
d_to_b(d);
printf("\n");
}
if(cmd == 2)
{
expression();
}
}while(cmd!=0);
cmd = -1;
break;
}
}while(cmd!=0);
return 0;
}
/*十进制转换为二进制*/
int d_to_b(int d)
{
SeqStack S;
int b;
/*初始化栈*/
init(&S,32);
/*d不为0，余数进栈*/
while(d)
{
push(&S, d % 2);
d /= 2;
}
/*依次出栈*/
while(!empty(&S))
{
pop(&S,&b);
printf("%d", b);
}
/*销毁栈*/
destroy(&S);
}
/*后缀表达式计算*/
int expression()
{
SeqStack S;
int i;
int op1, op2;
int x;
char exp[20]; /*后缀表达式*/
init(&S, 10);
printf("请输入一个后缀表达式(eg. 56+):");
scanf("%s", exp);
for(i=0;i<strlen(exp);i++)
{
switch(exp[i])
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
/*入栈*/
push(&S, exp[i]-48);
break;
case '+':
/*出2个*/
pop(&S, &op1);
pop(&S, &op2);
x = op1 + op2;
push(&S, x);
break;
case '-':
/*出2个*/
pop(&S, &op2);
pop(&S, &op1);
x = op1 - op2;
push(&S, x);
break;
case '*':
pop(&S, &op1);
pop(&S, &op2);
x = op1 * op2;
push(&S, x);
break;
case '/':
pop(&S, &op2);
pop(&S, &op1);
x = op1 / op2;
push(&S, x);
break;
}
}
pop(&S, &x);
printf("计算结果为：%s = %d\n", exp, x);
destroy(&S);
}seqstack.c
/*
seqstack.c
*/
#include <stdio.h>
#include <malloc.h>
#include "seqstack.h"
/* 1. 初始化 */
int init(SeqStack *S, int MaxSize)
{
/*申请内存空间*/
S->data = (DataType*)malloc(sizeof(DataType)*MaxSize);
if(!S->data)
{
printf("内存申请错误，初始化失败！[10001]\n");
return 10001;
}
S->maxsize = MaxSize;
S->top = -1;
return 0;
}
/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x)
{
/*是否满？*/
if(full(S))
{
printf("栈已满！10002\n");
return 10002;
}
S->top++; /*移动指针*/
S->data[S->top] = x;/*放入数据*/
return 0; /*OK*/
}
/* 3. 出栈 */
int pop(SeqStack *S, DataType *x)
{
/*是否空？*/
if(empty(S))
{
printf("栈为空！10003\n");
return 10003;
}
*x = S->data[S->top]; /*栈顶元素赋值给x*/
S->top--; /*移动栈顶指针*/
return 0;
}
/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x)
{
/*是否空？*/
if(empty(S))
{
printf("栈为空！10003\n");
return 10003;
}
*x = S->data[S->top]; /*栈顶元素赋值给x*/
return 0;
}
/* 5. 栈为空？*/
int empty(SeqStack *S)
{
return (S->top == -1)?1:0;
}
/* 6. 栈满？*/
int full(SeqStack *S)
{
return (S->top == S->maxsize - 1)?1:0;
}
/* 7. 销毁*/
int destroy(SeqStack *S)
{
free(S->data);
return 0;
}
/*长度*/
int length(SeqStack *S)
{
return (S->top+1);
}
/*清空*/
void Clear(SeqStack *S)
{
S->top=-1;
printf("栈已被清空");
}
/*打印*/
void show(SeqStack *S)
{
int i;
for(i=S->top;i>=0;--i)
{
printf("%d\n",S->data[i]);
}
printf("\n");
}
seqstack.h
/*
seqstack.h
顺序栈
*/
typedef int DataType;
typedef struct
{
DataType *data; /* 堆空间 */
int maxsize;
int top; /* 栈顶指针 */
}SeqStack;
/* 1. 初始化 */
int init(SeqStack *S, int MaxSize);
/* 2. 进（入）栈 */
int push(SeqStack *S, DataType x);
/* 3. 出栈 */
int pop(SeqStack *S, DataType *x);
/* 4. 取栈顶元素 */
int get_top(SeqStack *S, DataType *x);
/* 5. 栈为空？*/
int empty(SeqStack *S);
/* 6. 栈满？*/
int full(SeqStack *S);
/* 7. 销毁*/
int destroy(SeqStack *S);
/*长度*/
int length(SeqStack *S);
/*清空*/
void Clear(SeqStack *S);
/*打印*/
void show(SeqStack *S);小结
栈是一种操作受限的线性表，虽然操作受限，但是与线性表有点类似，只不过栈的插入和删除都在表尾而已。顺序栈虽然实现简单，但是其容易发生溢出，在栈满的时候，还要入栈，则会上溢，而在栈空的时候，还要出栈，则会下溢。栈的应用，先进后出的特点，所以后缀表达式计算式注意op1和op2内的值，＋，*操作没有影响。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
