逆波兰式（耿3.8）

Description

假设表达式由单字母变量和双目四则运算算符构成。试编写程序，将一个通常书写形式且书写正确的表达式转换为逆波兰式。

Input

输入由单字母变量和双目四则运算算符构成的表达式。

Output

输出其逆波兰式。

• Sample Input 

  (a+b)*c

• Sample Output

  ab+c*

• code:

  #include<stdio.h>  
  #include<stdlib.h>  
  #include<string.h>  
    
  typedef struct Stack{  
      char data;  
      struct Stack *next;  
  }Stack;  
    
  Stack *creat()  
  {  
      Stack *q=(Stack *)malloc(sizeof(Stack));  
      q->next=NULL;  
      return q;  
  }  
    
  char getTop(Stack *s)  
  {  
      return s->next->data;  
  }  
    
  void pop(Stack *s)  
  {  
      Stack *q=s->next;  
      s->next=q->next;  
      free(q);  
  }  
    
  void push(Stack *s,char b){  
      Stack *q=(Stack *)malloc(sizeof(Stack));  
      q->data=b;  
      q->next=s->next;  
      s->next=q;  
  }  
    
  int isEmpty(Stack *s){  
      if(s->next==NULL)return 1;  
      return 0;  
  }  
    
  int main()  
  {  
      char str[205];  
      char ans[205];  
      scanf("%s",&str);  
      int i;  
      Stack *s1=creat();  
      Stack *s2=creat();  
      int s=strlen(str);  
      for(i=0;i<s;i++)  
      {  
          switch(str[i])  
          {  
          case '(':  
              push(s1,str[i]);  
              break;  
          case ')':  
              while(getTop(s1)!='(')  
              {  
                  char tmp;  
                  tmp=getTop(s1);  
                  push(s2,tmp);  
                  pop(s1);  
              }  
              pop(s1);  
              break;  
          case '+':  
          case '-':  
              while(getTop(s1)!='(')  
              {  
                  char tmp;  
                  tmp=getTop(s1);  
                  push(s2,tmp);  
                  pop(s1);  
              }  
              push(s1,str[i]);  
              break;  
          case '*':  
          case '/':  
               while(!isEmpty(s1)&&getTop(s1)!='('&&getTop(s1)!='+'&&getTop(s1)!='-')  
               {  
                   char tmp;  
                   tmp=getTop(s1);  
                   push(s2,tmp);  
                   pop(s1);  
               }  
               push(s1,str[i]);  
               break;  
          default:  
               push(s2,str[i]);  
          }  
      }  
      while(!isEmpty(s1))  
      {  
          char tmp=getTop(s1);  
          push(s2,tmp);  
          pop(s1);  
      }  
      i=0;  
      while(!isEmpty(s2))  
      {  
          ans[i]=getTop(s2);  
          pop(s2);  
          i++;  
      }  
      int j;  
      for(j=i-1;j>=0;j--)  
      {  
          printf("%c",ans[j]);  
      }  
      printf("\n");  
      return 0;  
  }  

  
  

  思路：

  所谓的逆波兰表示法（Reverse Polish notation，RPN，或逆波兰记法），是一种数学表达式方式，在逆波兰记法中，所有操作符置于操作数的后面，因此也被称为后缀表示法。逆波兰记法不需要括号来标识操作符的优先级。（摘自维基）

  　　举个简单的例子，平常我们写的数学表达式a+b，就是一种中缀表达式，写成后缀表达式就是ab+。再举一个复杂的例子，中缀表达式(a+b)*c-(a+b)/e的逆波兰式是ab+c*ab+e/-。

  　　在弄清楚概念以及题目的要求之后，接下来就要编写算法了。那么将一个表达式转换为逆波兰式的算法思想是什么呢？

   

  　　(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应做一下逆序处理，因为此时表达式的首字符位于栈底；