第12关：中缀表达式转化为后缀表达式

任务描述

本关任务：输入一个中缀算术表达式，将其转换为后缀表达式。运算符包括+、-、*、/、(、)、=，参加运算的为小于10的自然数。（只考虑二元运算即可）

编程要求

输入

多组数据，每组数据一行，对应一个算术表达式，每个表达式均以“=”结尾。当表达式只有一个“=”时，输入结束。

输出

对于每组数据输出一行，为表达式的后缀式。

测试说明

平台会对你编写的代码进行测试：

测试输入： 9+(3-1)*3+1/2= 1+2= =

预期输出： 931-3*+12/+ 12+

代码

#include<iostream>

using namespace std;
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW - 2
#define Status int
typedef struct {
  char * base;
  char * top;
  int stacksize;
}
SqStack;
Status InitStack(SqStack & S) { //初始化栈
  S.base = new char[MAXSIZE];
  if (!S.base) return OVERFLOW;
  S.top = S.base;
  S.stacksize = MAXSIZE;
  return OK;
}
Status Push(SqStack & S, char e) { //入栈
  if (S.top - S.base == S.stacksize) //栈满
    return ERROR;
  * S.top = e;
  S.top++;
  return OK;
}
Status Pop(SqStack & S) { //出栈
  if (S.top == S.base) //栈空
    return ERROR;
  S.top--;
  return OK;
}
char GetTop(SqStack S) { //取栈顶元素
  if (S.top != S.base)
    return * (S.top - 1);
  return ERROR;
}
char Precede(char a, char b) { //比较符号优先级
  if ((a == '(' && b == ')') || (a == '=' && b == '='))
    return '=';
  else if (a == '=' || a == '(' || b == '(' || ((a == '+' || a == '-') && (b == '*' || b == '/')))
    return '<';
  else
    return '>';
}
void InfixToSuffix(SqStack op, char s[]) { //将中缀表达式转化为后缀表达式并输出 
  /**************begin************/
  SqStack op1; //放置操作数
  InitStack(op1); //初始化操作数栈op1
  int i = 0;
  while (1) {
    if (s[i] == '=') {
      break;
    } else {
      if (isdigit(s[i])) { //数字
        Push(op1, s[i]);
      } else {
          //不是数字
          //如果是左括号，直接入栈
          if(s[i]=='('){
              Push(op,s[i]);
              i++;
          }
        if (s[i] == ')') {
          //如果为右括号，则一一弹栈，直到左括号
          while (1) {
            char data = GetTop(op); //获取栈顶元素
            if (data == '(') {
                Pop(op);
                break;
            } else {
              Pop(op);
              Push(op1, data); //入栈
            }
          }
        } else {
            //一般字符
          char pre = Precede(GetTop(op), s[i]);
          //取栈顶元素进行字符串比较
          if (pre == '<') {
            //要压入的优先级大
            Push(op, s[i]);
          } else if (pre == '>' || pre == '=') {
            //要压入的优先级小
            while (1) {
              char data = GetTop(op); //获取栈顶元素
              if (data == '=') {
                //等号为预先压入的
                //把要压入的压入到op
                Push(op, s[i]); //入栈
                break;
              } else {
                char p = Precede(data, s[i]);
                if (p == '>') {
                  //栈顶元素比要压入的等级大，则进入op1
                  Pop(op); //出栈
                  Push(op1, data); //入栈
                } else if (p == '<') {
                  //把要压入的压入到op
                  Push(op, s[i]); //入栈
                  break;
                } else if(p == '=') {
                  //等于
                  Pop(op); //出栈
                  Push(op1, data); //入栈
                }
              }
            }
          }
        }
      }
    }
    i++;
  }
//   把操作数栈出栈到op1
  while (1) {
    char data = GetTop(op); //获取栈顶元素
    if (data == '=') {
      break;
    } else {
      if (data == ')' || data == '(' || data == '=') {
        Pop(op); //只出栈
      } else {
        Pop(op); //出栈
        Push(op1, data); //入栈
      }
    }
  }
  // 利用op栈倒置op1栈
  while (1) {
    char data = GetTop(op1); //获取栈顶元素
    if (!Pop(op1)) {
      //栈空
      break;
    } else {
        Push(op, data); //入栈
    }
  }
  //输出
  while (1) {
    char data = GetTop(op); //获取栈顶元素
    if (!Pop(op)) {
      //栈空
      break;
    } else {
      if (data != '=') {
        cout << data; //避免输出最先压入的“=”
      }
    }
  }
  cout << "\n";
  /**************end************/
}
int main() {
  SqStack op;
  InitStack(op); //初始化字符栈op
  Push(op, '='); //先在栈底放入'='便于以后比较符号优先级	
  char s[100];
  while (cin >> s) {
    if (s[0] == '=')
      break; //当表达式只有一个“=”时，输入结束 
    else
      InfixToSuffix(op, s); //将中缀表达式转化为后缀表达式并输出	
  }
  return 0;
}