栈的应用举例
进制转换
/* 进制转换，由十进制转换为8进制 */
void conversion()
{
SLinkList S;
SElemType e;
InitStack(&S);
int N;
scanf("%d",&N);
while (N) {
Push(S,N%8);
N /= 8;
}
/* 这时栈S刚好存放进制转换结果，把每一位按顺序pop出来就可以了 */
while (!StackEmpty(S)) {
Pop(S,&e);
printf("%d",e);
}
DestoryStack(&S);
}
括号匹配检测
/* 括号匹配检测 */
void matching()
{
SLinkList S;
SElemType e = 0;
InitStack(&S); /* 初始化栈空间 */
int c;
while ((c=getchar()) != '
') {
if(c == '(' || c == '[')
Push(S,c);
if(c == ')' || c == ']') {
GetTop(S,&e); /* 获取栈顶元素 */
if(c == ')' && e == '(')
Pop(S,&e); /* 栈顶元素和当前元素匹配则弹出 */
else if(c == ']' && e == '[')
Pop(S,&e);
else { /* 不匹配，则直接退出 */
printf("not pip
");
DestoryStack(&S);
return;
}
}
}
/* 最后检测栈是否空的 */
if (!StackEmpty(S)) {
printf("not pip
");
}else {
printf("good
");
}
DestoryStack(&S);
}
行编辑程序
/* 行编辑程序 */
void LineEdit()
{
SLinkList S;
SElemType e;
char str[100];
InitStack(&S); /* 初始化栈空间 */
int c;
while((c=getchar()) != EOF) {
if(c != '
') { /* 还没到达行尾 */
if(c == '#')
Pop(S,&e);
else if(c == '@')
ClearStack(S); /* 清空栈以撤消改行 */
else
Push(S,c); /* 将字符数据压入栈中 */
}
else {
// ... 在这里已经接收到一行字符，实际中可以传送至调用过程的数据区
int i = 0;
while(!StackEmpty(S)) {
Pop(S,&e); /* 弹出数据存放到数组中 */
str[i++] = e;
}
while (i>0) /* 逆向打印数组内容 */
printf("%c",str[--i]);
printf("
");
}
}
DestoryStack(&S);
}
迷宫求解
假设迷宫是这样的，用一个二位数组代表地图得到
示例代码如下
/* 栈的元素类型替换成如下 */
typedef struct {
int ord;
PosType seat; /* 通道块在地图中的坐标位置 */
int di; /* 从此通道走向下一个通道的方向 */
} SElemType;
typedef struct {
int i;
int j;
}PosType;
#define MAP_ROW 10
#define MAP_COL 10
/* 定义地图类型 */
typedef int Map[MAP_ROW][MAP_COL];
Map map = {
// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0
1, 0, 0, 1, 0, 0, 0, 1, 0, 1, // 1
1, 0, 0, 1, 0, 0, 0, 1, 0, 1, // 2
1, 0, 0, 0, 0, 1, 1, 0, 0, 1, // 3
1, 0, 1, 1, 1, 0, 0, 0, 0, 1, // 4
1, 0, 0, 0, 1, 0, 0, 0, 0, 1, // 5
1, 0, 1, 0, 0, 0, 1, 0, 0, 1, // 6
1, 0, 1, 1, 1, 0, 1, 1, 0, 1, // 7
1, 1, 0, 0, 0, 0, 0, 0, 0, 1, // 8
1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // 9
};
Map mfoot; /* 辅助地图，用来保存足迹 */
/* 打印地图 */
void printMap(Map map)
{
/* 打印列数 */
printf(" ");
for(int i=0;i<MAP_COL;i++)
printf("%d ",i);
printf("
");
for(int i=0;i<MAP_ROW;i++) {
printf("%2d ",i); /* 打印行数 */
for(int j=0;j<MAP_COL;j++)
if(map[i][j] == 1) printf("▇ ");
else if(map[i][j] == 2) printf("! ");
else printf(". ");
printf("
");
}
}
/* 标记足迹 */
void FootPrint(PosType pos)
{
mfoot[pos.i][pos.j] = 1;
}
int Pass(PosType pos)
{
if(mfoot[pos.i][pos.j] == 0 && map[pos.i][pos.j] == 0)
return TRUE; /* 当前位置没有标记过，可以通过 */
else
return FALSE;
}
/* 获取下一个位置 */
PosType NextPos(PosType pos, int setp)
{
switch (setp)
{
case 1:
pos.j++;
break;
case 2:
pos.i++;
break;
case 3:
pos.j--;
break;
case 4:
pos.i--;
break;
default:
break;
}
return pos;
}
int main()
{
SLinkList S;
SElemType e;
InitStack(&S); /* 初始化栈空间 */
printMap(map);
memset(mfoot,0,sizeof(Map)); /* 清空足迹 */
PosType start = {1,1};
PosType end = {8,8};
PosType curpos = start; /* 当前位置 */
int curstep = 1; /* 探索第一步 */
do{
if(Pass(curpos)) { /* 当前通道块没有到达过，可通行 */
FootPrint(curpos); /* 留下足迹 */
SElemType e = {curstep, curpos, 1};
Push(S,e); /* 加入路径 */
if(curpos.i == end.i && curpos.j == end.j ) { /* 到达出口位置 */
printf("finsh
");
break;
}
// printf("pos (%d,%d)
",curpos.i,curpos.j);
curpos = NextPos(curpos,1); /* 对于没有探索过的模块，下一个位置是东 */
curstep++;
}
else { /* 当前位置不能通过 */
if(!StackEmpty(S)) {
Pop(S,&e); /* 弹出上一步的通道块元素 */
while(e.di == 5 && !StackEmpty(S)) { /* 如果已经走完四个方向都不行 */
Pop(S,&e); /* 再退出上一个 */
}
}
if(e.di < 5) {
e.di++;
Push(S,e);
curpos = NextPos(e.seat,e.di); /* 换下一个地方探索 */
}
}
}while(!StackEmpty(S));
while(!StackEmpty(S)) {
Pop(S,&e);
map[e.seat.i][e.seat.j] = 2;
}
printMap(map);
DestoryStack(&S);
}
最后结果如下
表达式求值
/**
* 首先操作数栈为空栈，表达式起始符'#'为运算符栈栈底元素
* 依次读入表达式中每一个字符，若是操作数，则进OPND，若是运算符，则和OPTR栈的栈顶运算符比较优先级后
* 做相应的操作，直至整个表达式求值完毕（即OPTR栈顶元素变成'#')
*/
int isOPTR(int c)
{
if(c>='0' && c<='9')
return FALSE;
else
return TRUE;
}
/** 为了先算括号内的表达式，则符号( 还没入栈时则优先入栈，所以它在外面时总是最大的，
* 而当 ( 符号已经在栈里面，和其他符号比较时它又是最小的，必须让其他元素先进来
* 符号 )本身不入栈，一直在外面，所以优先级最高
* 除了栈外的( ，栈内的乘除优先级最高，因为除了括号外，总是需要先算括号，那么算括号就得让栈外 ( 先入栈
* 已经在栈内的 ( ，也就是说也就在括号里面，则优先级看
*
* 由规则3
*/
int Optr_Table[7][7] = {
// + - * / ( ) #
// +
'>', '>', '<', '<', '<', '>', '>',
// -
'>', '>', '<', '<', '<', '>', '>',
// *
'>', '>', '>', '>', '<', '>', '>',
// /
'>', '>', '>', '>', '<', '>', '>',
// (
'<', '<', '<', '<', '<', '=', ' ',
// )
'>', '>', '>', '>', ' ', '>', '>',
// #
'<', '<', '<', '<', '<', ' ', '='
};
int getIndex(int c)
{
switch (c) {
case '+': return 0;
case '-': return 1;
case '*': return 2;
case '/': return 3;
case '(': return 4;
case ')': return 5;
case '#': return 6;
default:
return 7;
}
}
/* 比较两个运算符的优先级 */
int Precede(int c1, int c2)
{
c1 = getIndex(c1);
c2 = getIndex(c2);
if(c1>6 || c2 >6)
return ' ';
return Optr_Table[c1][c2];
}
/* 计算操作 */
int Operate(int a, int theta, int b)
{
switch (theta) {
case '+': return a + b;
case '-': return b - a;
case '*': return a * b;
case '/': return a / b;
default:
return 0;
}
}
int main()
{
SLinkList OPTR; /* 寄存运算符 */
SLinkList OPND; /* 寄存操作数或运算结果 */
SElemType e;
SElemType top;
InitStack(&OPTR); /* 初始化栈空间 */
InitStack(&OPND);
Push(OPTR,'#');
GetTop(OPTR,&top);
int a,b;
int c = getchar();
while(c != '#' || top != '#') { /* 一个表达式还没结束，或者运算符还没到底 */
if(!isOPTR(c)) {
Push(OPND,c-'0'); /* 不是运算符，压入操作数栈中 */
c = getchar();
}
else {
GetTop(OPTR,&e);
switch (Precede(e,c)) /* 栈顶运算符和当前运算符比较优先级 */
{
case '<' : /* 栈顶元素优先级低 */
Push(OPTR,c);
c = getchar();
break;
case '=' : /* 脱括号并接收下一个字节 */
Pop(OPTR,&e);
c = getchar();
break;
case '>' : /* 运算符出栈并将计算结果如入栈 */
Pop(OPTR,&e);
Pop(OPND,&a);
Pop(OPND,&b);
Push(OPND,Operate(a,e,b));
break;
default:
break;
}
}
GetTop(OPTR,&top);
}
GetTop(OPND,&e);
printf("result: %d
",e);
DestoryStack(&OPTR);
DestoryStack(&OPND);
}