问题 D: 第4关：基于栈的中缀算术表达式求值

题目描述

本关任务：输入一个中缀算术表达式，求解表达式的值。运算符包括+、-、*、/、(、)、=，参加运算的数为double类型且为正数。（要求：直接针对中缀算术表达式进行计算，不能转换为后缀或前缀表达式再进行计算，只考虑二元运算即可。）

 

输入描述

多组数据，每组数据一行，对应一个算术表达式，每个表达式均以“=”结尾。当表达式只有一个“=”时，输入结束。参加运算的数为double类型。

 

输出描述

对于每组数据输出一行，为表达式的运算结果。输出保留两位小数

 

 

代码实现 

#include <iostream>

#include<iomanip>

#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW - 2
using namespace std;
typedef struct { //运算符栈
  char * base;
  char * top;
  int stacksize;
}
SqStack1;
int InitStack1(SqStack1 & S) { //运算符栈初始化
  S.base = new char[MAXSIZE];
  if (!S.base) return OVERFLOW;
  S.top = S.base;
  S.stacksize = MAXSIZE;
  return OK;
}
int Push1(SqStack1 & S, char e) { //运算符栈入栈
  if (S.top - S.base == S.stacksize) //栈满
    return ERROR;
  * S.top = e;
  S.top++;
  return OK;
}
int Pop1(SqStack1 & S) { //运算符栈出栈
  if (S.top == S.base) //栈空
    return ERROR;
  S.top--;
  return OK;
}
char GetTop1(SqStack1 S) { //运算符栈取栈顶元素
  if (S.top != S.base)
    return * (S.top - 1);
  return ERROR;
}
typedef struct { //操作数栈
  double * base;
  double * top;
  int stacksize;
}
SqStack2;
int InitStack2(SqStack2 & S) { //操作数栈初始化
  S.base = new double[MAXSIZE];
  if (!S.base) return OVERFLOW;
  S.top = S.base;
  S.stacksize = MAXSIZE;
  return OK;
}
int Push2(SqStack2 & S, double e) { //操作数栈入栈
  if (S.top - S.base == S.stacksize) //栈满
    return ERROR;
  * S.top = e;
  S.top++;
  return OK;
}
int Pop2(SqStack2 & S) { //操作数栈出栈
  if (S.top == S.base) //栈空
    return ERROR;
  S.top--;
  return OK;
}
double GetTop2(SqStack2 S) { //操作数栈取栈顶元素
  if (S.top != S.base)
    return * (S.top - 1);
  return ERROR;
}
double Calculate(double a, char op, double b) { //计算表达式“a op b”的值
  switch (op) {
    case '+':
      return a + b;
    case '-':
      return a - b;
    case '*':
      return a * b;
    case '/':
      return a / b;
  }
}

char Precede(char a, char b) { //比较运算符a和b的优先级
  if ((a == '(' && b == ')') || (a == '=' && b == '='))
    return '=';
  else if (a == '(' || a == '=' || b == '(' || (a == '+' || a == '-') && (b == '*' || b == '/'))
    return '<';
  else
    return '>';
}

double Evaluateexpression(SqStack1 OPTR, SqStack2 OPND, char s[]) {  
  int i = 0;  
  while (s[i] != '\0') { // 遍历整个中缀表达式  
    if (isdigit(s[i])) { // 如果是数字，则入栈  
      double num = s[i] - '0';  
      while (isdigit(s[i+1])) { // 连续的数字合并为一个数字  
        num = num * 10 + (s[++i] - '0');  
      }  
      Push2(OPND, num); // 将数字压入操作数栈  
    } else if (isoperator(s[i])) { // 如果是运算符，则与栈顶的两个元素进行运算，并将结果入栈  
      double b = Pop2(OPND); // 弹出第二个操作数  
      double a = Pop2(OPND); // 弹出第一个操作数  
      char op = s[i]; // 获取运算符  
      double result;  
      switch (op) {  
        case '+':  
          result = Calculate(a, op, b);  
          break;  
        case '-':  
          result = Calculate(a, op, b);  
          break;  
        case '*':  
          result = Calculate(a, op, b);  
          break;  
        case '/':  
          result = Calculate(a, op, b);  
          break;  
      }  
      Push2(OPND, result); // 将运算结果压入操作数栈  
    } else if (s[i] == '(') { // 如果是左括号，则将其压入运算符栈，并处理其后的元素  
      Push1(OPTR, '(');  
      while (s[i] != ')') {  
        i++;  
      }  
    } else if (s[i] == ')') { // 如果是右括号，则直到遇到左括号或运算符时停止处理栈顶元素，继续处理下一个元素  
      while (OPTR.top != OPTR.base && Precede(Pop1(OPTR), s[i]) != '=') {  
        Push2(OPND, Pop1(OPTR)); // 将出栈的运算符放入操作数栈中作为操作数处理  
      }  
      Push1(OPTR, s[i]); // 将右括号压入运算符栈中等待处理下一个左括号或运算符  
    } else if (s[i] == '=') { // 当表达式只有一个“=”时，开始求解表达式的值  
      double result = Evaluateexpression(OPTR, OPND, s); // 递归求解表达式的值，并返回结果  
      return result;  
    } else { // 其他字符为非法字符，直接忽略  
      i++;  
    }  
    i++; // 处理下一个字符  
  }  
  // 中缀表达式求值结束，栈中应该只剩下一个元素，即为表达式的结果  
  return Pop2(OPND);  
}


int main() { //设OPTR和OPND分别为运算符栈和操作数栈
  SqStack1 OPTR;
  InitStack1(OPTR); //初始化OPND栈
  SqStack2 OPND;
  InitStack2(OPND); //初始化OPTR栈
  Push1(OPTR, '='); //将表达式起始符“=”压入OPTR栈        
  char s[100];
  while (cin >> s) { //循环读入多组数据
    if (s[0] == '=')
      break; //当表达式只有一个“=”时，输入结束
    //输出中缀算术表达式的值
    cout << fixed << setprecision(2) << Evaluateexpression(OPTR, OPND, s) << fixed << setprecision(2) << endl;

  }
  return 0;
}