标签：

前言

栈的一个广泛应用就是讲中缀表达式转换为后缀表达式。所谓中缀表达式就是我们从小到大所接触的：10+3-6/2+4*5 之类的算数表达式。而后缀表达式又称为逆波兰表达式，

它是由波兰逻辑学家J.Lukasiewicz于1929年提出的。

为什么需要后缀表达式

对于计算机而言，后缀表达式非常方便进行运算。举例来说，对于 "3,5,+," 这样的后缀表达式，其算法如下：
从左至右读取每个字符，若是数字，则入栈；若是操作符，则作用于栈中所弹出的两个数字。

转换算法

那么如何将中缀表达式转换为后缀呢？最简单的步骤如下：

1.按照优先级将整个表达式从里到外加满括号

2.将操作符移动到距离被操作数最近的括号外

3.去掉所有括号后的结果即为后缀表达式。

按照上面的步骤，我们对 10+3-6/2+4*5 进行转换：

第一步：加括号

(((10+3)-(6/2))+(4*5))

第二步：移动操作符

第三步：去掉括号

10 3 + 6 2 /- 4 5 * +

对于人类而言，这是最简单的一种办法了。但是本文的目的是描述中缀转换后缀的程序算法。

算法如下：

初始化一个空栈来保存操作符

循环中缀表达式中每一个字符：

1.当读到操作数时，立即把它放到输出中。操作符不立即输出，而是放进栈中。

2.当遇到左括号时，也将其放到栈中。

3.如果见到一个右括号，那么我们将栈元素弹出，将弹出的符合写出直到我们遇见一个（对应的）左括号，但是
这个左括号，只弹出，不输出。

4.如果我们见到任何其他的符号（“+”，“-”，“*”，“/”,"("）,则循环弹出栈顶元素到输出，

直到遇见优先级更低的元素为止（也就是说：如果栈顶符号的优先级大于等于当前符号的优先级，则从栈中弹出元素到输出。）。
有一个例外：除非是在处理一个“)”的时候，否则我们绝不从栈中移走“(”。对于这种操作，“+”的优先级最低，而“(”的优先级
最高。当从栈中弹出元素的工作完成后，我们再将操作符入栈。

5.最后，如果我们读到输入的末尾，我们将栈元素弹出，直到栈变为空栈，将弹出的元素写到输出。

完整的代码如下：

package com.lemon.stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.regex.Pattern;

public class PostfixConverter {
	
	public static void main(String[] args) {
		//String infixExpression="10+3-6/2+4*5";
		String infixExpression="(((10+3)-(6/2))+(4*5))";
		buildPostfixExpression(infixExpression);
	}
	
	public static List<String> buildPostfixExpression(String infixExpression){
		List<String> result=new ArrayList<String>();
		Stack<String> operatorStack=new Stack<String>();
		StringTokenizer strTokenizer = new StringTokenizer(infixExpression, "+-*/()", true);
		String currentEle;
		while (strTokenizer.hasMoreTokens()) {  
			currentEle = strTokenizer.nextToken().trim();
			if(currentEle!=null && !currentEle.equals("")){
				if(isDigital(currentEle)){
					result.add(currentEle);
				}else if(currentEle.equals("(")){
					operatorStack.push(currentEle);
				}else if(currentEle.equals(")")){
					while(!operatorStack.isEmpty() && !operatorStack.peek().equals("(")){
						result.add(operatorStack.pop());
					}
					operatorStack.pop();
				}else if(currentEle.equals("+")||currentEle.equals("-")||
						currentEle.equals("*")||currentEle.equals("/")||
						currentEle.equals("(")||currentEle.equals(")")){
					while(!operatorStack.isEmpty() 
							&&
							(!currentEle.equals(")") && !operatorStack.peek().equals("("))&&
							getPriority(operatorStack.peek())>=getPriority(currentEle)){
						result.add(operatorStack.pop());
					}
					operatorStack.push(currentEle);
				}
			}
			
		}
		while(!operatorStack.isEmpty()){
			result.add(operatorStack.pop());
		}
		System.out.println(result.toString());
		return result;
	}
	
	public static int getPriority(String operator){
		if(operator.equals("+")||operator.equals("-")){
			return 1;
		}else if(operator.equals("*")||operator.equals("/")){
			return 2;
		}else if(operator.equals("(")){
			return 3;
		}
		return 0;
	}
	
	/** 
	 * 判断字符串是否是数字类型 
	 * @param str 
	 * @return true:数字;false:非数字
	 */  
	public static boolean isDigital(String str) {  
		String numRegex = "^\\d+(\\.\\d+)?$"; 
		return Pattern.matches(numRegex, str);  
	}  
}

栈的应用之中缀表达式转后缀

标签：

原文地址：http://blog.csdn.net/yanan_seachange/article/details/51323729