西北工业大学noj数据结构008逆波兰式（耿3.8）

做这道题之前需要先清楚逆波兰式的概念
逆波兰式是计算机常用的表达式语言，借用知乎大佬的讲解：
逆波兰表达式，英文为 Reverse Polish notation，跟波兰表达式（Polish notation）相对应。之所以叫波兰表达式和逆波兰表达式，是为了纪念波兰的数理科学家 Jan Łukasiewicz。其在著作中提到：我在1924年突然有了一个无需括号的表达方法，我在文章第一次使用了这种表示法。平时我们习惯将表达式写成 (1 + 2) * (3 + 4)，加减乘除等运算符写在中间，因此称呼为中缀表达式。而波兰表达式的写法为 (* (+ 1 2) (+ 3 4))，将运算符写在前面，因而也称为前缀表达式。逆波兰表达式的写法为 ((1 2 +) (3 4 +) *)，将运算符写在后面，因而也称为后缀表达式。波兰表达式和逆波兰表达式有个好处，就算将圆括号去掉也没有歧义。上述的波兰表达式去掉圆括号，变为 * + 1 2 + 3 4。逆波兰表达式去掉圆括号，变成 1 2 + 3 4 + * 也是无歧义并可以计算的。事实上我们通常说的波兰表达式和逆波兰表达式就是去掉圆括号的。而中缀表达式，假如去掉圆括号，将 (1 + 2) * (3 + 4) 写成 1 + 2 * 3 + 4，就改变原来意思了。

作者：黄兢成
链接：https://www.zhihu.com/question/41103160/answer/452481026
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
本题的思路为，构建两个栈，一个栈存放输入的字符串，字符串加工后输入到另一个栈中，具体实现如下：
(1)首先，需要分配2个栈，栈s1用于临时存储运算符（含一个结束符号），此运算符在栈内遵循越往栈顶优先级越高的原则；栈s2用于输入逆波兰式，为方便起见，栈s1需先放入一个优先级最低的运算符，在这里假定为’#’；

(2)从中缀式的左端开始逐个读取字符x，逐序进行如下步骤：

1.若x是操作数，则分析出完整的运算数（在这里为方便，用字母代替数字），将x直接压入栈s2；

2.若x是运算符，则分情况讨论：

若x是’(’，则直接压入栈s1；

若x是’)’，则将距离栈s1栈顶的最近的’(‘之间的运算符，逐个出栈，依次压入栈s2，此时抛弃’(’；

若x是除’(‘和’)'外的运算符，则再分如下情况讨论：

若当前栈s1的栈顶元素为’(’，则将x直接压入栈s1；

若当前栈s1的栈顶元素不为’(’，则将x与栈s1的栈顶元素比较，若x的优先级大于栈s1栈顶运算符优先级，则将x直接压入栈s1。否者，将栈s1的栈顶运算符弹出，压入栈s2中，直到栈s1的栈顶运算符优先级别低于（不包括等于）x的优先级，或栈s2的栈顶运算符为’(’，此时再则将x压入栈s1;

【第二步是一个循环，要把中缀式读完。第三步是在循环之外】

(3)在进行完(2)后，检查栈s1是否为空，若不为空，则将栈中元素依次弹出并压入栈s2中（不包括’#’）；

(4)完成上述步骤后，栈s2便为逆波兰式输出结果。但是栈s2应做一下逆序处理，因为此时表达式的首字符位于栈底；
　　话不多说上代码

#include<stdio.h>
#include<stdlib.h>
#define max 1000
#define ok 1
#define error 0
typedef struct DNode
{
    char a[max];
    int top;//栈顶元素的下标

}Stack;
void InitStack(Stack *s)
{
    s->top=-1;//构造空栈
}
int Push(Stack*s,char x)//进栈函数
{
    if(s->top==max-1) return error;
    s->top++;
    s->a[s->top]=x;
    return ok;
}
int Pop(Stack*s,char *x)//将栈顶元素放到x中弹出
{
    if(s->top==-1) return error;
    else
    {
        *x=s->a[s->top];
        s->top--;
        return ok;
    }
}
int StackEmpty(Stack *s)//检查栈是否为空
{
    if(s->top==-1) return ok;
    else return error;
}
char Top(Stack *s)//读取栈顶元素
{
  if(s->top==-1) return error;
    else
    {
        char x=s->a[s->top];
        return x;
    }
}
  char *RPExpression(char *e)
  /* 返回表达式e的逆波兰式 */
  {
     //栈s1用于存放运算符，栈s2用于存放逆波兰式
     Stack s1,s2;
     InitStack(&s1);
     InitStack(&s2);

     //假设字符'#'是运算级别最低的运算符，并压入栈s1中
     Push(&s1,'#');

     //p指针用于遍历传入的字符串，ch用于临时存放字符,length用于计算字符串长度
     char *p=e,ch;
     int length=0;
     for(;*p!='\0';p++)//逐个字符访问
     {
         switch(*p)
         {
             //遇'('则直接入栈s1
             case '(':
                 Push(&s1,*p);
                 break;
             //遇')'则将距离栈s1栈顶的最近的'('之间的运算符，逐个出栈，依次送入栈s2,此时抛弃'('
             case ')':
                 while(Top(&s1)!='(')
                 {
                     Pop(&s1,&ch);
                     Push(&s2,ch);
                 }
                 Pop(&s1,&ch);
                 break;
             //遇下列运算符，则分情况讨论：
             //1.若当前栈s1的栈顶元素是'('，则当前运算符直接压入栈s1；
             //2.否则，将当前运算符与栈s1的栈顶元素比较，若优先级较栈顶元素大，则直接压入栈s1中,
             //  否则将s1栈顶元素弹出，并压入栈s2中，直到栈顶运算符的优先级别低于当前运算符，然后再将当前运算符压入栈s1中
             case '+':
             case '-':
                 for(ch=Top(&s1);ch!='#';ch=Top(&s1))
                 {
                     if(ch=='(')
                     {
                         break;
                     }
                     else
                     {
                         Pop(&s1,&ch);
                         Push(&s2,ch);
                     }
                 }
                 Push(&s1,*p);
                 length++;
                 break;
             case '*':
             case '/':
                 for(ch=Top(&s1);ch!='#'&&ch!='+'&&ch!='-';ch=Top(&s1))
                 {
                     if(ch=='(')
                     {
                         break;
                     }
                     else
                     {
                         Pop(&s1,&ch);
                         Push(&s2,ch);
                     }
                 }
                 Push(&s1,*p);
                 length++;
                 break;
             //遇操作数则直接压入栈s2中
             default:
                 Push(&s2,*p);
                 length++;
         }
     }
     //若栈s1非空，则将栈中元素依次弹出并压入栈s2中
      while(!StackEmpty(&s1)&&Top(&s1)!='#')
     {
         Pop(&s1,&ch);
         Push(&s2,ch);
     }
     //最后将栈s2输出，逆序排列成字符串;
     char *result;
     result=(char *)malloc(sizeof(char)*(length+1));
     result+=length;
     *result='\0';
     result--;
     for(;!StackEmpty(&s2);result--)
     {
         Pop(&s2,&ch);
         *result=ch;
     }
     ++result;
     return result;
 }
int main()
{
    char e[max];char *r;
    scanf("%s",e);
    r = (char*)malloc(sizeof(char)*max);
    r=RPExpression(e);
    puts(r);
    return 0;

}