【数据结构】复杂表达式的求值

参考博客：前缀、中缀、后缀表达式

一、表达式的三种表示法

1.  中缀表示法 

     运算符放在两个运算对象中间，这是我们书写的时候最熟悉的一种形式，如：（2 + 3）* 7

2.  前缀表示法

     前缀是附加在表达式前面的内容。又称为波兰前缀表示法，因为他是由波兰数学家Jan Lukasiewicz发明的。使用前缀表示法后，就完全不需要括号了。例如，表达式（2 + 3）*  7以波兰前缀表示法可以写成： * + 2 3 7

     计算方法：

     算波兰表达式时，无需记住运算的层次，只需要直接寻找第一个运算的操作符。以二元运算为例，从左至右读入表达式，遇到一个操作符后跟随两个操作数时，则计算之，然后将结果作为操作数替换这个操作符和两个操作数；重复此步骤，直至所有操作符处理完毕。因为在正确的前缀表达式中，操作数必然比操作符多一个，所以必然能找到一个操作符符合运算条件；而替换时，两个操作数和一个操作符替换为一个操作数，所以减少了各一个操作符和操作数，仍然可以迭代运算直至计算整个式子。多元运算也类似，遇到足够的操作数即产生运算，迭代直至完成。迭代结束的条件由表达式的正确性来保证。下面是一个例子，演示了每一步的运算顺序：

− × ÷ 15 − 7 + 1 1 3 + 2 + 1 1 =
− × ÷ 15 − 7 2       3 + 2 + 1 1 =
− × ÷ 15  5            3 + 2 + 1 1 =
− × 3                     3 + 2 + 1 1 =
− 9                           + 2 + 1 1 =
− 9                                 + 2 2 =
− 9                                       4 =
5

等价的中缀表达式:  ((15 ÷ (7 − (1 + 1))) × 3) − (2 + (1 + 1)) = 5

3.后缀表达式

    后缀表达式与前缀表达式类似，只是运算符位于操作数之后。

    他和前缀表示法都对计算机比较友好，但他很容易用堆栈解析，所以在计算机中用的很多。他的解释过程一般是：操作数入栈；遇到操作符时，操作数出栈，求值，将结果入栈；当一遍后，栈顶就是表达式的值。因此逆波兰表达式的求值使用堆栈结构很容易实现，和能很快求值。 注意：逆波兰记法并不是简单的波兰表达式的反转。因为对于不满足交换律的操作符，它的操作数写法仍然是常规顺序，如，波兰记法“/ 6 3”的逆波兰记法是“6 3 /”而不是“3 6 /”；数字的数位写法也是常规顺序。 为了更好的了解前缀表达式的计算过程，举个例子：5 3 2 * + 4 - 5 +，计算过程如下：

后缀表达式的求值扫描到的元素栈（栈底到栈顶）                  说明55操作数直接入栈35 3操作数直接入栈25 3 2操作数直接入栈*5 6遇到操作符，弹出两个实数，求值，压栈+11遇到操作符，弹出两个实数，求值，压栈411 4操作数直接入栈-7遇到操作符，弹出两个实数，求值，压栈57 5操作数直接入栈+12计算结果为12

二 、 算法实现

public static final Pattern UNSIGNED_DOUBLE = Pattern.compile("((\\d+\\.?\\d*)|(\\.\\d+))([Ee][-+]?\\d+)?.*?");public static final Pattern CHARACTER = Pattern.compile("\\S.*?");

1. 后缀表达式求值

伪代码：

a. 初始化生成了一个由双精度实数构成的栈。

b. do 

if（下一个输入元素为数值）

读取下一个元素并压到栈中。

else

   {

           读取下一个字符，该字符是一个运算符。

           从栈中弹出两个实数

           将两个数用运算符组合（第二个弹出的数值为左操作数）

然后将结果压入栈中。

    }

       while (表达式中有更多的输入)。

c. 到此为止，栈中仅包含一个数值，该数值就是表达式的值。

/** * 后缀表达式的求值算法 * @param expression * @return */public static double evaluateReversePolishNotation(String expression){// 使用一个栈来保存表达式中的数值Stack<Double> numbers = new Stack<Double>();// 将表达式转换成一个Scanner类的对象，以便更易于处理Scanner input = new Scanner(expression);// next存储的是表达式的下一个片段：数值、运算符或括号String next;while (input.hasNext()){if (input.hasNext(UNSIGNED_DOUBLE)){next = input.findInLine(UNSIGNED_DOUBLE);numbers.push(new Double(next));} else {next = input.findInLine(CHARACTER);double operand1, operand2;if (numbers.size() < 2){throw new IllegalArgumentException("Illegal expression.");}switch (next.charAt(0)){case '+':operand2 = numbers.pop();operand1 = numbers.pop();numbers.push(operand1 + operand2);break;case '-':operand2 = numbers.pop();operand1 = numbers.pop();numbers.push(operand1 - operand2);break;case '*':operand2 = numbers.pop();operand1 = numbers.pop();numbers.push(operand1 * operand2);break;case '/':operand2 = numbers.pop();operand1 = numbers.pop();numbers.push(operand1 / operand2);break;default:throw new IllegalArgumentException("Illegal input expression.");}}}if (numbers.size() != 1){throw new IllegalArgumentException("Illegal input expression.");}return numbers.pop();}

String s3 = "5 3 2 *+4-5+";double value3 = CalculateUtils.evaluateReversePolishNotation(s3);System.out.println(value3);

5 3 2 *+4-5+的计算结果为：12.0

2. 中缀表达式求值

        由于后缀表达式非常易于求值，所以计算普通的中缀表达式的一种策略是先将它转载成后缀表达式，然后在计算对应的后最表达式。

伪代码：

 a. 初始化一个字符栈用于存储运算符和括号。

 b. do

        if (下一个输入时左括号）

             读取左括号并将它压到栈中。

        else if (下一个输入时数值或其他操作数)

             读取操作数并将它输出

        else if (下一个输入是运算符)

                 {

                        出栈并打印运算符，直到下列三种情况中的一种发生:（1） 栈为空；（2）栈中的下一个符号是左括号；（3）栈中的下一个符号是优                           先级比下一个输入中的运算符更低的运算符。当发生三种情况中的某种时，停止出栈，读取下一个输入符号，并将该符号压入栈中。

                 }

                  else 

                  {

                        读取并放弃下一个输入符号（它应该是一个右括号）。出栈并打印输出从栈中弹出的运算符，直到栈中的下一个符号是左括号位置。                            （如果没有出现左括号，打印出出错信 息表明括号不平衡，终止程序。）最后，出栈并丢弃左括号。

                   }

              while  （表达式中有更多信息读入）

         c. 出栈并打印输出栈中所有属于的运算符。（不应该是左括号，否则输入表达式的括号是不平衡的。）

// 中缀表达式转换为波兰后缀表达式的算法public static String infixToReversePolishNotation(String expression){StringBuffer outStrBuffer = new StringBuffer();// 使用一个栈来存储运算符和括号Stack<Character> operations = new Stack<Character>();// 将表达式转换成一个Scanner类的对象，以便更易于处理Scanner input = new Scanner(expression);// next存储的是表达式的下一个片段：数值、运算符或括号String next;while (input.hasNext()){// 如果输入为数值或其他操作数，读取操作数并将它if (input.hasNext(UNSIGNED_DOUBLE)){next = input.findInLine(UNSIGNED_DOUBLE);outStrBuffer.append(next);outStrBuffer.append(" ");} else {next = input.findInLine(CHARACTER);switch (next.charAt(0)){case '(':operations.push(next.charAt(0));break;case '+':case '-':case '*':case '/':while (true){if (operations.empty() || operations.peek().equals('(') || priorityCompare(operations.peek(), next.charAt(0)) == -1){operations.push(next.charAt(0));break;}else {outStrBuffer.append(operations.pop());outStrBuffer.append(" ");}}break;case ')':while (true){if (!operations.peek().equals('(')){outStrBuffer.append(operations.pop());outStrBuffer.append(" ");} else {operations.pop();break;}}break;default:throw new IllegalArgumentException("Illegal input expression.");}}}

String s4 = "5*(9.1+3.2)/(1-5+4.88)";String outStr = infixToReversePolishNotation(s4);System.out.println(outStr);double value4 = CalculateUtils.evaluateReversePolishNotation(outStr);System.out.println(value4);

结果：

5 9.1 3.2 + * 1 5 - 4.88 + /69.88636363636364

 此程序是笔者为了说明上述概念而编写，仅做了简单的测试，不保证其中没有Bug，因此不要将其用于除研究之外的其他场合。