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

原创 2015年07月09日 10:57:41

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

一、表达式的三种表示法

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 +,计算过程如下:
后缀表达式的求值
扫描到的元素 栈(栈底到栈顶)                   说明
5 5 操作数直接入栈
3 5 3 操作数直接入栈
2 5 3 2 操作数直接入栈
* 5 6 遇到操作符,弹出两个实数,求值,压栈
+ 11 遇到操作符,弹出两个实数,求值,压栈
4 11 4 操作数直接入栈
- 7 遇到操作符,弹出两个实数,求值,压栈
5 7 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,因此不要将其用于除研究之外的其他场合。

JAVA数据结构复杂表达式求值

  • 2014年01月03日 14:22
  • 3KB
  • 下载

数据结构之栈与队列数学表达式的求值

数学表达式的计算     课本上使用c去实现个位数字的加减乘除,于是我将它扩展到了浮点数的四则运算   用了逆波兰表达式,具体怎么算还是百度一下吧,我的表达能力肯定不如百度啦   另外我终于去学...
  • biqigu
  • biqigu
  • 2016年09月09日 12:13
  • 937

[数据结构]从中序表达式到逆序表达式(逆波兰式)(四则运算表达式求值)

#include #include #define max 100 char ex[max]; /*存储后序表达式*/ /*函数功能:将中序表达式转化为后序表达式*/ void tra...

SDUT 2133 数据结构实验之栈三:后缀式求值

数据结构实验之栈三:后缀式求值 Time Limit: 1000ms   Memory limit: 65536K  有疑问?点这里^_^ 题目描述 对于一个...

数据结构实验之栈三:后缀式求值

http://acm.sdut.edu.cn/sdutoj/problem.php?action=showproblem&problemid=2133 数据结构实验之栈三:后缀式求值 ...
  • cswhit
  • cswhit
  • 2016年08月25日 11:12
  • 148

nyoj128 前缀式求值(栈---递归---数据结构)

前缀式计算 时间限制:1000 ms  |  内存限制:65535 KB 难度:3 描述 先说明一下什么是中缀式: 如2+(3+4)*5这种我们最常见的式子就是中...

数据结构实验之栈三:后缀式求值

数据结构实验之栈三:后缀式求值 Time Limit: 1000MS Memory limit: 65536K 题目描述 对于一个基于二元运算符的后缀表示式(基本...

数据结构实验之栈三:后缀式求值(基本操作数一位正整数)

Think: 1知识点 1>后缀表达式求值方式: 从左往右运算,遇到数字存到栈里,遇到运算符将栈顶两个元素弹出进行运算,运算完成将运算结果入栈;后缀表达式——百度百科链接 2>stack容器初...

SDUTACM 数据结构实验之栈三:后缀式求值

Problem Description 对于一个基于二元运算符的后缀表示式(基本操作数都是一位正整数),求其代表的算术表达式的值。 Input 输入一个算术表达式的后缀式字符串,以‘...
  • Key_MQL
  • Key_MQL
  • 2016年10月06日 15:39
  • 162
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【数据结构】复杂表达式的求值
举报原因:
原因补充:

(最多只允许输入30个字)