前缀，中缀，后缀表达式的转换，表达式的求值

一：说明
	我们日常生活中见到的表达式是中缀表达式，如：1+((2+3)*4)-5，对于人们来说中缀表达式
	感觉直观，计算方便。但对于计算机来说并不是这样，因此为了方便计算机的计算，就出现了前缀表
	达式，如：-+1*+2345 和后缀表达式：123+4*+5-。 
	
二：前缀表达式的操作
	1、由中缀表达式转化成前缀表达式步骤：
	(1) 初始化两个栈：运算符栈S1和储存中间结果的栈S2；
	(2) 从右至左扫描中缀表达式；
	(3) 遇到操作数时，将其压入S2；
	(4) 遇到运算符时，比较其与S1栈顶运算符的优先级：
	(4-1) 如果S1为空，或栈顶运算符为右括号“)”，则直接将此运算符入栈；
	(4-2) 否则，若优先级比栈顶运算符的较高或相等，也将运算符压入S1；
	(4-3) 否则，将S1栈顶的运算符弹出并压入到S2中，再次转到(4-1)与S1中新的栈顶运算符相比较；
	(5) 遇到括号时：
	(5-1) 如果是右括号“)”，则直接压入S1；
	(5-2) 如果是左括号“(”，则依次弹出S1栈顶的运算符，并压入S2，直到遇到右括号为止，此时将这一对括号丢弃；
	(6) 重复步骤(2)至(5)，直到表达式的最左边；
	(7) 将S1中剩余的运算符依次弹出并压入S2；
	(8) 依次弹出S2中的元素并输出，结果即为中缀表达式对应的前缀表达式。

例如，将中缀表达式“1+((2+3)×4)-5”转换为前缀表达式的过程如下：

扫描到的元素	S2(栈底->栈顶)	S1 (栈底->栈顶)	说明
5	5	空	数字，直接入栈
-	5	-	S1为空，运算符直接入栈
)	5	- )	右括号直接入栈
4	5 4	- )	数字直接入栈
×	5 4	- ) ×	S1栈顶是右括号，直接入栈
)	5 4	- ) × )	右括号直接入栈
3	5 4 3	- ) × )	数字
+	5 4 3	- ) × ) +	S1栈顶是右括号，直接入栈
2	5 4 3 2	- ) × ) +	数字
(	5 4 3 2 +	- ) ×	左括号，弹出运算符直至遇到右括号
(	5 4 3 2 + ×	-	同上
+	5 4 3 2 + ×	- +	优先级与-相同，入栈
1	5 4 3 2 + × 1	- +	数字
到达最左端	5 4 3 2 + × 1 + -	空	S1中剩余的运算符

因此结果为“- + 1 × + 2 3 4 5”。

2、由前缀表达式求解表达式值得步骤：
	从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算(栈顶元素op次顶元素)并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果。

	例如前缀表达式“- × + 3 4 5 6”：
	(1) 从右至左扫描，将6、5、4、3压入堆栈；
	(2) 遇到+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素，注意与后缀表达式做比较），计算出3+4的值，得7，再将7入栈；
	(3) 接下来是×运算符，因此弹出7和5，计算出7×5=35，将35入栈；
	(4) 最后是-运算符，计算出35-6的值，即29，由此得出最终结果。
		可以看出，用计算机计算前缀表达式的值是很容易的。

三：后缀表达式的操作
	1、由中缀表达式转换成后缀表达式，（步骤与中->前差不多，但是要注意不同点）
	(1) 初始化两个栈：运算符栈S1和储存中间结果的栈S2；
	(2) 从左至右扫描中缀表达式；
	(3) 遇到操作数时，将其压入S2；
	(4) 遇到运算符时，比较其与S1栈顶运算符的优先级：
	(4-1) 如果S1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
	(4-2) 否则，若优先级比栈顶运算符的高，也将运算符压入S1（注意转换为前缀表达式时是优先级较高或相同，而这里则不包括相同的情况；
	(4-3) 否则，将S1栈顶的运算符弹出并压入到S2中，再次转到(4-1)与S1中新的栈顶运算符相比较；
	(5) 遇到括号时：
	(5-1) 如果是左括号“(”，则直接压入S1；
	(5-2) 如果是右括号“)”，则依次弹出S1栈顶的运算符，并压入S2，直到遇到左括号为止，此时将这一对括号丢弃；
	(6) 重复步骤(2)至(5)，直到表达式的最右边；
	(7) 将S1中剩余的运算符依次弹出并压入S2；
	(8) 依次弹出S2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式（转换为前缀表达式时不用逆序）。

例如，将中缀表达式“1+((2+3)×4)-5”转换为后缀表达式的过程如下：

扫描到的元素	S2(栈底->栈顶)	S1 (栈底->栈顶)	说明
1	1	空	数字，直接入栈
+	1	+	S1为空，运算符直接入栈
(	1	+ (	左括号，直接入栈
(	1	+ ( (	同上
2	1 2	+ ( (	数字
+	1 2	+ ( ( +	S1栈顶为左括号，运算符直接入栈
3	1 2 3	+ ( ( +	数字
)	1 2 3 +	+ (	右括号，弹出运算符直至遇到左括号
×	1 2 3 +	+ ( ×	S1栈顶为左括号，运算符直接入栈
4	1 2 3 + 4	+ ( ×	数字
)	1 2 3 + 4 ×	+	右括号，弹出运算符直至遇到左括号
-	1 2 3 + 4 × +	-	-与+优先级相同，因此弹出+，再压入-
5	1 2 3 + 4 × + 5	-	数字
到达最右端	1 2 3 + 4 × + 5 -	空	S1中剩余的运算符

因此结果为“1 2 3 + 4 × + 5 -”（注意需要逆序输出）。

	2、由后缀表达式求解表达式值得步骤：
	与前缀表达式类似，只是顺序是从左至右：
	从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算
	（次顶元素 op 栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果。
	例如后缀表达式“3 4 + 5 × 6 -”：
	(1) 从左至右扫描，将3和4压入堆栈；
	(2) 遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素，注意与前缀表达式做比较），计算出3+4的值，得7，再将7入栈；
	(3) 将5入栈；
	(4) 接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
	(5) 将6入栈；
	(6) 最后是-运算符，计算出35-6的值，即29，由此得出最终结果。
	
四：从上面可以看出，由中缀表达式转化成前缀表达式和后缀表达式然后求值是相当繁琐的，有时候为了方便可以使用Rahio引擎，直接通过中缀表达式求值。如通过javascript中的eval(String script)函数。

说明：本片文章绝大部分内容是http://blog.csdn.net/antineutrino/article/details/6763722这篇文章的，博主并不是抄袭，只是想发表一下自己的学习感想。下面是我自己写的源代码，纯粹自娱自乐！！！！！！！！。

	使用时有很多的限制:

	1）、只支持算数运算：+ - * / %
	2）、对于Invertor类支持整数和字母运算，对于Calculate类只支持整数运算
	3）、不检查表达式正确与否，因此保证输入的表达式是正确的

package com.chen.change;

import java.util.Stack;

/**
 * 由中缀表达式求前缀表达式和后缀表达式
 * @author CHJ
 *
 */
public class Invertor {
	
	/**
	 * 由中缀表达式求前缀表达式
	 * @param nifix	中缀表达式
	 * @return	前缀表达式
	 */
	public static String getPrefixFromNifix(String nifix){
		
		Stack<Character> s1 = new Stack<Character>();// 存放字符
		Stack<Character> s2 = new Stack<Character>();// 存放数字和字符
		int lastIndex = nifix.length() - 1;
		for(int i = lastIndex; i >= 0; i--) {
			
			char strTemp = nifix.charAt(i);// 这里使用nifix.infexOf()不太好，因为返回值的问题
			if(Character.isDigit(strTemp) 
					|| (strTemp >= 65 && strTemp <= 90) 
					|| (strTemp >= 97 && strTemp <= 127)) {
				
				s2.push(strTemp);
			} else if(strTemp == ')') {
				
				s1.push(strTemp);
			} else if(strTemp == '(') {
				
				char temp = ' ';
				while(!s1.isEmpty() && (temp=s1.pop()) != ')' ) {
					s2.push(temp);
				}
			} else if(Utils.isOperator(strTemp)) {
				
				if(s1.isEmpty()) {
					
					s1.push(strTemp);
				}else {
					
					char temp = ' ';
					while(!s1.isEmpty()) {
						
						temp = s1.pop();
						if(Utils.priorityCompare(strTemp, temp) >= 0) {
							
							s1.push(temp);
							s1.push(strTemp);
							break;
						}else {
							
							s2.push(temp);
							if(s1.isEmpty()) {// 必不可少，这里容易出错
								
								s1.push(strTemp);
								break;
							}
						}
					}
				}
			}			
		}
		while(!s1.isEmpty()) {

			s2.push(s1.pop());
		}
		StringBuilder sb = new StringBuilder();
		while(!s2.isEmpty()) {
			
			sb.append(s2.pop());
		}
		return sb.toString();
	}
	/**
	 * 由中缀表达式求后缀表达式
	 * @param nifix	中缀表达式
	 * @return	后缀表达式
	 */
	public static String getPostfixFromNifix(String nifix){
		
		Stack<Character> s1 = new Stack<Character>();// 存放字符
		Stack<Character> s2 = new Stack<Character>();// 存放数字和字符
		int lastIndex = nifix.length() - 1;
		for(int i = 0; i <= lastIndex; i++) {
			
			char strTemp = nifix.charAt(i);// 这里使用nifix.infexOf()不太好，因为返回值的问题
			if(Character.isDigit(strTemp)
					|| (strTemp >= 65 && strTemp <= 90) 
					|| (strTemp >= 97 && strTemp <= 127)) {
				
				s2.push(strTemp);
			} else if(strTemp == '(') {
				
				s1.push(strTemp);
			} else if(strTemp == ')') {
				
				char temp = ' ';
				while(!s1.isEmpty() && (temp=s1.pop()) != '(' ) {
					s2.push(temp);
				}
			} else if (Utils.isOperator(strTemp)) {

				if (s1.isEmpty()) {

					s1.push(strTemp);
				} else {

					char temp = ' ';
					while (!s1.isEmpty()) {

						temp = s1.pop();
						if (Utils.priorityCompare(strTemp, temp) == 1) {

							s1.push(temp);
							s1.push(strTemp);
							break;
						} else {

							s2.push(temp);
							if (s1.isEmpty()) {

								s1.push(strTemp);
								break;
							}
						}
					}
				}
			}
		}
		while(!s1.isEmpty()) {

			s2.push(s1.pop());
		}
		StringBuilder sb = new StringBuilder();
		while(!s2.isEmpty()) {
			
			sb.append(s2.pop());
		}
		return sb.reverse().toString();
	}

}<pre name="code" class="java">package com.chen.change;

import java.util.Stack;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

/**
 * 由前缀、中缀或者后缀表达式求表达上的值
 * @author CHJ
 *
 */
public class Calculate{

	/**
	 * 由前缀表达式求表达式的值
	 * @param prefix	前缀表达式
	 * @return	表达式计算结果
	 */
	public static int getValueFromPrefix(String prefix) {

		Stack<Integer> stack = new Stack<Integer>();
		int lastIndex = prefix.length() - 1;
		for(int i =lastIndex ; i >= 0; i--) {
			
			char strTemp = prefix.charAt(i);
			if(Character.isDigit(strTemp)) {
				
				stack.push((int)strTemp-48);
			} else {
				
				int opd1 = stack.pop();
				int opd2 = stack.pop();
				int result = Utils.getResult(opd1, opd2, strTemp);
				stack.push(result);
			}
		}
		return stack.pop();
	}

	/**
	 * 由中缀表达式求表达式的值
	 * @param nifix	中缀表达式
	 * @return	计算结果
	 */
	public static int getValueFromNifix(String nifix) {
		
		// 由两种方式：中缀-->前缀-->求值  或者  中缀-->后缀-->求值
//		String prefix = Invertor.getPrefixFromNifix(nifix);
//		return getValueFromPrefix(prefix);
		
		// 也可以使用脚本引擎来做
		ScriptEngineManager sem = new ScriptEngineManager();
		ScriptEngine engine = sem.getEngineByName("javascript");
		try {
			return (int)((double)engine.eval(nifix));// 这里要注意一下
		} catch (ScriptException e) {
			e.printStackTrace();
			System.out.println("结果出错，返回-1");
			return -1;
		}
	}

	/**
	 * 由后缀表达式求表达式的值
	 * @param postfix	后缀表达式
	 * @return	计算结果
	 */
	public static int getValueFromPostfix(String postfix) {
		
		Stack<Integer> stack = new Stack<Integer>();
		int lastIndex = postfix.length() - 1;
		for(int i = 0 ; i <= lastIndex; i++) {
			
			char strTemp = postfix.charAt(i);
			if(Character.isDigit(strTemp)) {
				
				stack.push((int)strTemp-48);
			} else {
				
				int opd1 = stack.pop();
				int opd2 = stack.pop();
				int result = Utils.getResult(opd2, opd1, strTemp);// 注意opd1和opd2的顺序
				stack.push(result);
			}
		}
		return stack.pop();
	}

}

package com.chen.change;
/**
 * 本项目的工具类
 * @author CHJ
 *
 */
public class Utils {

	/**
	 * 优先级的比较：
	 * op1 > op2 return 1
	 * op1 = op2 return 0
	 * op1 < op2 return -1 
	 * @author CHJ
	 *
	 */
	public static int priorityCompare(char op1, char op2) {

		int result = 1;
		switch(op1) {
		
		case '*':
		case '/':
		case '%':result = (op2 == '*' || op2 == '/' || op2 == '%' ? 0 : 1);
				 break;
		case '+':
		case '-':if(op2 == '*' || op2 == '/' || op2 == '%'){
			 		result = -1;
				 } else {
					result = op2 == ')' || op2 == '(' ? 1 : 0;
				 }
				break;
		}
		return result;
				
	}
	/**
	 * 判断一个字符是不是运算符 +,-,*,/,%中的一种
	 * @param op	给定字符
	 * @return	返回判断结果
	 */
	public static boolean isOperator(char op) {
		
		return (op == '+' || op == '-' || op == '*'
				|| op == '/' || op == '%');
	}
	/**
	 * 根据操作符计算两个操作数，返回结果
	 * @param opd1	操作数1
	 * @param opd2	操作数2
	 * @param operator	操作符
	 * @return	运算结果
	 */
	public static int getResult(int opd1, int opd2, char operator) {
		
		if(operator == '+') {
			
			return opd1 + opd2;
		} else if(operator == '-') {
			
			return opd1 - opd2;
		} else if(operator == '*') {
			
			return opd1 * opd2;
		} else if(operator == '/') {
			
			return opd1 / opd2;
		} else if(operator == '%') {
			
			return opd1 % opd2;
		} else{
			
			System.out.println("出错");
			return -1;
		}
	}
}

package com.chen.change;

public class Test {

	public static void main(String[] args) {
			
//			String nifix = "1+((2+3)*4)-5";// prefix = -+1*+2345 postix = 123+4*+5-
			String nifix = "2*3/(2-1)+5*(4-1)";// +/*23-21*5-41
			System.out.println("中缀表达式为：" + nifix);
			System.out.println("计算结果为：" + Calculate.getValueFromNifix(nifix));
			
			String prefix = Invertor.getPrefixFromNifix(nifix);
			System.out.println("前缀表达式为：" + prefix);
			System.out.println("计算结果为：" + Calculate.getValueFromPrefix(prefix));
			
			String postfix = Invertor.getPostfixFromNifix(nifix);
			System.out.println("后缀表达式为：" + postfix);
			System.out.println("计算结果为：" + Calculate.getValueFromPostfix(postfix));
			
//			中缀表达式为：1+((2+3)*4)-5
//			计算结果为：16
//			前缀表达式为：-+1*+2345
//			计算结果为：16
//			后缀表达式为：123+4*+5-
//			计算结果为：16

	}
}

前缀，中缀，后缀表达式的转换，表达式的求值

猜你喜欢