栈的应用

一、表达式求值

表达式求值问题是：用户输入一个包含“+”、“-”、“*”、“/”、正整数和圆括号的合法数学表达式，计算该表达式的运算结果。

为了方便，假设该表达式都是合法的数学表达式，例如，exp="1+2*(4+12)"；在设计相关算法中用到栈，这里采用顺序栈存储结构。 

例如:    Exp = a*b + (c - d / e) *f

前缀式: + * a b * - c / d e f

中缀式:  a * b + c - d / e * f

后缀式:  a b * c d e / - f * +  

经过分析，表达式的三种表示法有以下特点:

1. 操作数之间的相对次序不变；
2. 运算符的相对次序不同；
3. 若中缀式丢失括号信息，则运算的次序不确定;
4. 后缀表达式中已考虑了运算符的优先级，没有括号，只有操作数和运算符。

1）算数表达式exp->后缀表达式postexp

初始化运算符栈op;
将'='进栈;
从exp读取字符ch;
while (ch!='\0')
{   if (ch不为运算符)
　　　将后续的所有数字均依次存放到postexp中,并以字符'#'标志数值串结束;
     else 
         switch(Precede(op栈顶运算符,ch))
         {
         case '<':   //栈顶运算符优先级低
    将ch进栈;  从exp读取下字符ch;  break;
         case '=':   //只有栈顶运算符为'(',ch为')'的情况
退栈; 从exp读取下字符ch; break;
         case '>':    //栈顶运算符应先执行,所以出栈并存放到postexp中
退栈运算符并将其存放到postexp中; break;
        }
}

若字符串exp扫描完毕,则将运算符栈op中'='之前的所有运算符依次出栈并存放到postexp中。最后得到后缀表达式postexp;

代码：

struct 　　   //设定运算符优先级

{　char ch;   //运算符
　 int pri;   //优先级
} lpri[]={{'=',0},{'(',1},{'*',5},{'/',5},{'+',3},
    {'-',3},{')',6}},
  rpri[]={{'=',0},{'(',6},{'*',4},{'/',4},{'+',2},
    {'-',2},{')',1}};
int leftpri(char op)    //求左运算符op的优先级
{  int i;
   for (i=0;i<MaxOp;i++)
if (lpri[i].ch==op) return lpri[i].pri;
}
int rightpri(char op)  //求右运算符op的优先级
{  int i;
   for (i=0;i<MaxOp;i++)
if (rpri[i].ch==op) return rpri[i].pri;
}

bool InOp(char ch)       //判断ch是否为运算符
{  if (ch=='(' || ch==')' || ch=='+' || ch=='-' 
       || ch=='*' || ch=='/')
return true;
   else
return false;
}
int Precede(char op1,char op2)  //op1和op2运算符优先级的比较结果
{  if (leftpri(op1)==rightpri(op2))
return 0;
   else if (leftpri(op1)<rightpri(op2))
return -1;
   else
return 1;

}

void trans(char *exp,char postexp[])     
//将算术表达式exp转换成后缀表达式postexp
{  struct
   {  char data[MaxSize]; //存放运算符
int top; //栈指针
   } op; //定义运算符栈
   int i=0; //i作为postexp的下标
   op.top=-1;
   op.top++;                  //将'='进栈
   op.data[op.top]='='; 
   while (*exp!='\0') //exp表达式未扫描完时循环
   {  if (!InOp(*exp)) //为数字字符的情况
{  while (*exp>='0' && *exp<='9') //判定为数字
   {  postexp[i++]=*exp;
exp++;
   }
   postexp[i++]='#'; //用#标识一个数值串结束

}

    else //为运算符的情况
switch(Precede(op.data[op.top],*exp))
{
case -1:    //栈顶运算符的优先级低:进栈
op.top++;op.data[op.top]=*exp;
exp++;    //继续扫描其他字符
break;
case 0:    //只有括号满足这种情况
op.top--;    //将(退栈
exp++;    //继续扫描其他字符
break;
case 1:             //退栈并输出到postexp中
postexp[i++]=op.data[op.top];
op.top--;
break;
}

  } //while (*exp!='\0')

    while (op.data[op.top]!='=') 
        //此时exp扫描完毕,退栈到'='为止
    {  postexp[i++]=op.data[op.top];
op.top--;  
    }
    postexp[i]='\0'; //给postexp表达式添加结束标识

}

2）后缀表达式求值

对后缀表达式求值过程是：从左到右读入后缀表达式，若读入的是一个操作数，就将它入数值栈，若读入的是一个运算符op，就从数值栈中连续出栈两个元素(两个操作数)，假设为x和y，计算x op y之值,并将计算结果入数值栈；对整个后缀表达式读入结束时，栈顶元素就是计算结果。       

while (从postexp读取字符ch,ch!='\0')
{    若ch为数字,将后续的所有数字构成一个整数存放到数值栈st中。
     若ch为“+”,则从数值栈st中退栈两个运算数,相加后进栈st中。
     若ch为“－”,则从数值栈st中退栈两个运算数,相减后进栈st中。
     若ch为“*”,则从数值栈st中退栈两个运算数,相乘后进栈st中。
     若ch为“/”,则从数值栈st中退栈两个运算数,相除后进栈st中(若除数为零,则提示相应的错误信息)。
}

若字符串postexp扫描完毕,则数值栈op中的栈顶元素就是表达式的值。

代码：

float compvalue(char exp[]) //计算后缀表达式的值
{  struct 
   {  float data[MaxSize]; //存放数值
      int top; //栈指针
   } st; //定义数值栈
   float d; char ch; int t=0; //t作为exp的下标
   st.top=-1; ch=exp[t];t++;
   while (ch!='\0') //exp字符串未扫描完时循环
   {  switch (ch)
{
case'+':st.data[st.top-1]=
                 st.data[st.top-1]+st.data[st.top];
  st.top--;break;
      case '-':st.data[st.top-1]=
                 st.data[st.top-1]-st.data[st.top];
   st.top--;break;
case '*':st.data[st.top-1]=
                 st.data[st.top-1]*st.data[st.top];

   st.top--;break;

       case '/': 
           if (st.data[st.top]!=0)
st.data[st.top-1]=
                 st.data[st.top-1]/st.data[st.top];
     else
     {   printf("\n\t除零错误!\n");
   exit(0); //异常退出
     }
     st.top--;break;
  default: 
            d=0; //将数字字符转换成数值存放到d中
while (ch>='0' && ch<='9')   //为数字字符
{   d=10*d+ch-'0';  
    ch=exp[t];t++;
      }
st.top++; st.data[st.top]=d;
}
ch=exp[t];t++;
     }
     return st.data[st.top];

} 

二、求解迷宫问题

求迷宫问题就是求出从入口到出口的路径。在求解时,通常用的是“穷举求解”的方法，即从入口出发，顺某一方向向前试探,若能走通,则继续往前走；否则沿原路退回，换一个方向再继续试探,直至所有可能的通路都试探完为止。为了保证在任何位置上都能沿原路退回（称为回溯），需要用一个后进先出的栈来保存从入口到当前位置的路径。

 为了表示迷宫,设置一个数组mg,其中每个元素表示一个方块的状态,为0时表示对应方块是通道,为1时表示对应方块为墙。

1）算法设计      

 对于迷宫中的每个方块，有上下左右四个方块相邻，如下图所示，第i行第j列的当前方块的位置为(i,j)，规定上方方块为方位0，顺时针方向递增编号。

在试探过程中，假设从方位0到方位3的方向查找下一个可走的方块。

为了便于回溯，对于可走的方块都要进栈，并试探它的下一可走的方位，将这个可走的方位保存到栈中，为此将栈定义为:

typedef struct
{  int i; //当前方块的行号
   int j; //当前方块的列号
   int di; //di是下一可走相邻方位的方位号

} Box; //定义方块类型

typedef struct
{  Box data[MaxSize];
   int top; //栈顶指针

} StType; //顺序栈类型

2）实现代码

bool mgpath(int xi,int yi,int xe,int ye)
//求解路径为:(xi,yi)->(xe,ye)
{  int i,j,k,di,find;
   StType st; //定义栈st
   st.top=-1; //初始化栈顶指针
   st.top++; //初始方块进栈
   st.data[st.top].i=xi; st.data[st.top].j=yi;
   st.data[st.top].di=-1; mg[xi][yi]=-1; 
   while (st.top>-1) //栈不空时循环
   { i=st.data[st.top].i;j=st.data[st.top].j;
di=st.data[st.top].di; //取栈顶方块
if (i==xe && j==ye) //找到了出口,输出路径
{   printf("迷宫路径如下:\n");
    for (k=0;k<=st.top;k++)
    {  printf("\t(%d,%d)",st.data[k].i,st.data[k].j);
if ((k+1)%5==0) //每输出每5个方块后换一行
printf("\n");
    }
    printf("\n");
    return true; //找到一条路径后返回true

}

   find=0;
   while (di<4 && find==0) //找下一个可走方块
   {  di++;
      switch(di)
      {
      case 0:i=st.data[st.top].i-1;j=st.data[st.top].j;
             break;
case 1:i=st.data[st.top].i;j=st.data[st.top].j+1;
             break;
case 2:i=st.data[st.top].i+1;j=st.data[st.top].j;
             break;
case 3:i=st.data[st.top].i,j=st.data[st.top].j-1;
             break;
}
if (mg[i][j]==0) find=1; //找到下一个可走相邻方块

   }

  if (find==1) //找到了下一个可走方块
  {  st.data[st.top].di=di; //修改原栈顶元素的di值
     st.top++; //下一个可走方块进栈
     st.data[st.top].i=i; st.data[st.top].j=j;
     st.data[st.top].di=-1;
     mg[i][j]=-1; //避免重复走到该方块
  }
  else //没有路径可走,则退栈
  { mg[st.data[st.top].i][st.data[st.top].j]=0;
　　　　　　　//让该位置变为其他路径可走方块
st.top--; //将该方块退栈
   }
 }
 return false; //表示没有可走路径,返回false
}