Shunting Yard表达式解析器中的一元减号

Question

Shunting Yard表达式解析器中的一元减号

12

这是我的表达式解析器，使用逆波兰算法，除了一个情况，它都表现得很好。当我使用一元负号（比如 -2*3）时，它无法计算（我认为这是因为算法没有处理这种情况）。有简单的方法可以修复吗？（这只是一个简单的解析器，我只需要支持括号、加、减、乘、除和幂次运算）

#include <cctype>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cmath>
using namespace std;
int olaviat (char c) {
   /*************
    **Operator precedence 
    *************/
  switch(c) {
       case '-' : case '+' :
           return 1 ;
       case '*' : case '/' :
           return 2 ;
       case '^' :
           return 3 ;
       default :
           return 0 ;
  }
}
double eval(char *exp) {
    /*************
    **Convert to reverse polish
    *************/
    char n [50] , o[50] ;
    static int nl = 0  , ol = 0 ;

    while (*exp) {
            while(isspace(*exp)) *exp++ ;
        if(*exp == '(') {
             o[ol++]  = *exp++ ;
           }
        else if (*exp == ')'){
            while(o[--ol]!='('){
                    n[nl++] = o[ol];
                    n[nl++] = ' ';
                  }
                  *exp++;
        }
        else if (isdigit(*exp)) {
          while (isdigit(*exp)) {
            n[nl++] = *exp++ ;
          }
        n[nl++] = ' ' ;
        }
        else if (strchr("+-*/^",*exp)){
            if(olaviat(*exp) > olaviat(o[ol-1])) {
               o[ol++]  = *exp++ ;


            }
            else {
                    if(olaviat(*exp) == olaviat(o[ol-1]) && olaviat(*exp)== 3) {
                      o[ol++]  = *exp++ ;
                    }else{
                n[nl++] = o[ol-1] ;
                n[nl++] = ' ' ;
                o[--ol] = '\0' ;

                    }
            }
        }

    }

for (int k = ol-1 ; k >= 0 ; k --){
    n[nl++] = o[k];
    n[nl++] = ' ' ;
}
/*******************************/
cout << "Reverse Polish" << endl ;
for (int i = 0 ; i < nl-1 ; i++){
        cout << n[i]  ;
    }
cout << endl ;
//n[nl+1] = '\0' ;
/*******************************
**Calculate Result
*******************************/
    double temp[50];
    char *e ;
    ol = 0;
   int  nol = 0 ;
    e=n ;
    int digitcount = 0;
    while (*e) {
            while (isspace(*e)) *e++;
        if (isdigit(*e)) {
          while (isdigit(*e)) {
             o[ol++] =*e++ ;
             digitcount++ ;
          }
        temp[nol++] = atof(o) ;
        for (int i = 0 ; i < digitcount ; i++)
            o[i]='\0' ;
        ol=0;
        digitcount = 0 ;
        }
        else if (strchr("+-*/^",*e)){
          // char opr ;
           double tempAns = 0;
           switch (*e) {
              case '+' :
                  tempAns = temp[nol-2] + temp [nol-1] ;
                  break ;
              case '-' :
                  tempAns = temp [nol-2] - temp [nol-1] ;
                  break;
              case '*' :
                  tempAns = temp [nol-2] * temp [nol-1] ;
                  break;
              case '/' :
                  tempAns = temp[nol-2] / temp[nol-1];
                  break ;
              case '^' :
                  tempAns = pow(temp[nol-2],temp [nol-1]);
                  break ;
              default :
                cout << "\n Unknown error" ;
                continue;
           }
           *e++ ;
           nol--;
           temp[nol-1] = tempAns ;
           temp[nol] = NULL ;
        }
        else {
            break ;
        }
    }
    double ans = temp[0];

  return ans ;
}

int main() {

char exp[100];
char c;
start :
    cin.get (exp , 99);
    cout << "\n\tANS= " << eval(exp)  ;
    cout << endl ;
    system("PAUSE");
    return 0;
}

- PedramH

尽管这是一个不同的问题，但我在我的回答中概述了一个解决方案：https://dev59.com/UnHYa4cB1Zd3GeqPPL59#16392115 - rici

2个回答

1

一种选择是在第一个字符为“-”时在前面加上0。如果“-”在括号后面，也必须这样做。

更好的方法是实现一元减运算符或将其视为数字文字的一部分。

- jmihalicza

+1，您还需要查找表达式中其他地方隐藏的一元运算符 - 和 +，例如 "1-(-2)" 或 "1*-2"。 Bracer 使用搜索/替换来解决这个问题。 - user7116

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- BitParser · Accepted Answer

上述选项是正确的，但它会变得非常繁琐且容易出错。考虑这个例子2*-(1+2)^-(2+5*-(2+4))。正如您所看到的，您需要考虑许多事情。此外，每当您找到*-（时，例如，您知道将使用*(0-（...替换它，这将编码为一个繁琐的递归函数。最好的解决方案要简单得多。在解析运算符时，考虑运算符为-且前面有另一个运算符、左括号前缀或是输入的第一个字符(这些情况意味着它是一元减而不是二元减)，在这种情况下，将其更改为另一个字符，比如u (这是我的情况)，并使其优先级与^相同。此外，将其视为数字字面量的一部分也有它的陷阱。想象一下-2^4这样的情况。在 Wolfram Alpha 中，您将得到-16而不是16。考虑使用堆栈。它们会让您的生活更轻松。让我解释一下我的意思。考虑您输入了以下内容:

2 / - 7 + ( - 9 * 8 ) * 2 ^ - 9 - 5

进行我建议的替换后，它会变成这样:

2 / u 7 + ( u 9 * 8 ) * 2 ^ u 9 - 5

现在您的运算符优先级切换应该改为：

switch(c)
{
       case '-' : case '+' :
           return 1 ;
       case '*' : case '/' :
           return 2 ;
       case '^' : case 'u': //note the 'u' operator we added
           return 3 ;
       default :
           return 0 ;
}

当然，您需要进行更改以支持此一元运算符。