将中缀表达式转换为后缀表达式

中缀表达式:(6/2*3+9)/2+(3+1-1)*3+10/2

后缀表达式:6 2 / 3 * 9 + 2 / 3 1 + 1 - 3 * +10 2 / +

转换顺序如下：







实现代码如下，可直接运行，仅供测试使用，可能还存在bug。

package com.example;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
* Created by Yawinstake on 2016/12/25
*/

/**
* only support Integer
*/
public class CalcTest {
private  final String[] TAGS = new String[]{"+","-","*","/","(",")"};
//缓存中缀表达式解析结果
private  final List<String> CACHE_INFIX = new ArrayList<>();
//缓存后缀表达式结果
private  final List<String> CACHE_SUFFIX = new ArrayList<>();
//用于解析后缀表达式中间栈
private  final Stack<String> tempStack = new Stack<>();
//用于计算最终结果栈，最后只剩下一个数据时即为计算结果
private  final Stack<Double> calcStack = new Stack<>();
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
String input = scanner.nextLine();
new CalcTest().calculateTest(input);
}
public  void calculateTest(String s){
if(s == null){
return;
}
split(s);
String[] args_infix = CACHE_INFIX.toArray(new String[CACHE_INFIX.size()]);
System.out.println("parse infix data:"+printStringArray(args_infix));
translate(args_infix);
String[] args_suffix = CACHE_SUFFIX.toArray(new String[CACHE_SUFFIX.size()]);
System.out.println("suffix data:"+printStringArray(args_suffix));
System.out.println("calc result is:"+calculateUseSuffix(args_suffix));
}

private double calculateUseSuffix(String[] args_suffix){
if(args_suffix == null || args_suffix.length == 0){
return 0;
}
//遇到符号则将其前两位置数字进行运算
for(int i= 0;i<args_suffix.length;i++){
if(isNumeric(args_suffix[i])){
calcStack.push(Double.parseDouble(args_suffix[i]));
}else{
double number2 = calcStack.pop();
double number1 = calcStack.pop();
double result = calc(number1,number2,args_suffix[i]);
calcStack.push(result);
}
}
return calcStack.pop();

}

private double calc(double number1, double number2,String operator){
if( operator== null){
return 0f;
}
try{
if(operator.equals("+")){
return number1 + number2;
}else if(operator.equals("-")){
return number1 - number2;
}else if(operator.equals("*")){
return number1 * number2;
}else if(operator.equals("/")){
return number1 / number2;
}
}catch (Exception e){

}
return 0f;
}

//可以修改此方法支持其他类型
public boolean isNumeric(String s){
if(s == null || s.trim().length() == 0){
return false;
}
Pattern mPattern = Pattern.compile("[0-9]*");
Matcher matcher = mPattern.matcher(s);
return matcher.matches();
}

/**
* 将中缀表达式转换为后缀表达式
* @param args
*/
private  void translate(String[] args){
if(args == null || args.length == 0){
return;
}
for(int i=0;i<args.length;i++){
String arg = args[i];
//数字输出，运算符进栈，括号匹配出栈，栈顶优先级低出栈
if(isTag(arg)){
if(arg.equals(")")){
//should pop
while(!tempStack.empty()){
String popTag = tempStack.pop();
if(popTag.equals("(")){
break;
}
addToSuffix(popTag);
}
}else {
/**
* 判断栈内数据是否为空
* 不为空时循环取出栈顶数据与当前遍历数据比较优先级
* 结果为false时出栈，直到结果为true时退出循环
* 不论是否执行循环，最终都需要把当前的数据压入栈中
*/
while(!tempStack.empty()){
String topArg = tempStack.peek();
//
if(isTagHighPriorityToStackFirst(topArg,arg)) {
break;
}
String popTag = tempStack.pop();
addToSuffix(popTag);
}
tempStack.push(arg);
}
}else{
CACHE_SUFFIX.add(arg);
if(i == args.length - 1){
while(!tempStack.empty()){
String popTag = tempStack.pop();
addToSuffix(popTag);
}
}
}
System.out.println("arg is "+arg+",tempStack is"+tempStack+",CACHE_SUFFIX is "+CACHE_SUFFIX);
}
}

private void addToSuffix(String tag){
if(tag == null || tag.length() == 0){
return;
}
if(isTagCanAdd(tag)){
CACHE_SUFFIX.add(tag);
}
}

/**
*
* @param topTag 栈顶
* @param currentTag 当前数据
* @return
* 当栈顶为"("时，返回true
* 当栈顶优先级等于当前要入栈数据时，返回false
* 当栈顶优先级高于要入栈数据时，返回false
* 当栈顶优先级低于要入栈数据时，返回true
*/
private  boolean isTagHighPriorityToStackFirst(String topTag , String currentTag){
if(topTag.equals(currentTag)){
return false;
}
if(topTag.equals("(")){
return true;
}
if(topTag.equals("*") || topTag.equals("/")){
return false;
}else{
if(currentTag.equals("+") || currentTag.equals("-")){
return false;
}
}
return true;
}

private  boolean isTag(String s){
if(s == null || s.trim().length() == 0){
return false;
}
for(String tag : TAGS){
if(tag.equals(s)){
return true;
}
}
return false;
}

private  boolean isTagCanAdd(String s){
if(s == null || s.trim().length() == 0){
return false;
}
for(String tag : TAGS){
if(tag.equals(s) && !tag.equals(")") && !tag.equals("(")){
return true;
}
}
return false;
}

private  boolean isArgNotContainAnyTag(String arg){
for(String tag : TAGS){
if(arg.contains(tag)){
return false;
}
}
return true;
}

private static ArrayList<String> spitBytag(String s , String tag){
if(s == null || tag == null){
return null;
}
ArrayList<String> list = new ArrayList<>();
if(!s.contains(tag)){
list.add(s);
return list;
}
String[] args = s.split(changeTag(tag));
if(args.length == 1){
if(s.indexOf(tag) == 0){
list.add(tag);
list.add(args[0]);
}else {
list.add(args[0]);
list.add(tag);
}
}else {
for (String arg : args) {
//ignore space
if (arg != null && arg.trim().length() != 0) {
if (list.size() == 0) {
list.add(arg);
} else {
if(!list.get(list.size()-1).equals(tag)) {
list.add(tag);
}
list.add(arg);
}
}else{
list.add(tag);
}
}
}
//        System.out.println("s is "+s+",tag is "+tag +",list is "+list+",args length is "+args.length);
return list;
}

private static String changeTag(String tag){
return "["+tag+"]";
}

private static String printStringArray(String[] array){
if(array == null){
return "";
}
StringBuilder sb = new StringBuilder();
for(String s : array){
if(sb.length() == 0){
sb.append(s);
}else{
sb.append(",").append(s);
}
}
return sb.toString();
}

private  void split(String s){
split(s,0);
}

/**
* 采用递归
* @param s
* @param index
*/
private  void split(String s,final int index){
if(index == TAGS.length){
return;
}
List<String> list = spitBytag(s,TAGS[index]);
if(list != null && list.size() > 0){
if(list.size() == 1){
String subS = list.get(0);
if (subS.length() == 1 || isArgNotContainAnyTag(subS)) {
CACHE_INFIX.add(subS);
}else{
split(subS,index+1);
}
}else {
for (String subS : list) {
if (subS != null) {
if (subS.length() == 1 || isArgNotContainAnyTag(subS)) {
CACHE_INFIX.add(subS);
}else{
split(subS,index+1);
}
}
}
}
}
}
}

执行结果：

parse infix data:(,6,/,2,*,3,+,9,),/,2,+,(,3,+,1,-,1,),*,3,+,10,/,2

suffix data:6,2,/,3,*,9,+,2,/,3,1,+,1,-,3,*,+,10,2,/,+

calc result is:23.0

部分内容参考了：http://blog.csdn.net/antineutrino/article/details/6763722/