逆波兰表达式（RPN）算法简单实现

一、预处理

给定任意四则运算的字符串表达式（中缀表达式），preDeal预先转化为对应的字符串数组，其目的在于将操作数和运算符分离。

例如给定四则运算内的中缀表达式：

String infix = "100+8*5-(10/2)*5+10.5";

字符串数组化后得：

{"100","+","8","*","5","-","(","10","/","2",")","+","10.5"}

二、中缀表达式转后缀表达式

规则：

遍历中缀表达式，

A、如果遇到操作数直接输出

B、如果遇到运算符，分情况：

B1：如果是*、/或者(这三个运算符，直接压栈

B2：如果是)，则出栈直到遇到(位置。（左括号和有括号并不参与拼接后缀表达式）。

B3：如果是+或者-，先弹栈直到栈空，再讲当前的+或者-压栈。

其中情况B可以总结：

遇到右括号出栈直到匹配左括号，遇到操作符，如果其优先级高于栈顶元素，则继续压栈，否则出栈。

三、计算后缀表达式

规则：

遍历后缀表达式：

A、遇到操作数压栈

B、遇到运算符则将栈顶和次栈顶两个元素取出参与对应的运算，再将运算结结果压栈。

四、Java算法实现

 package agstring;
 import java.util.*;

 public class RPN {
     public static String[] preDeal(String infix){
         infix = infix.trim();
         int length = infix.length();
         ArrayList<String> infixOfArrayList = new ArrayList<String>();
         char currChar;
         int index = 0;
         final String regex = "\\+|-|\\*|\\/|\\(|\\)";
         for (int i = 0; i < length; i++) {
             currChar = infix.charAt(i);
             if(String.valueOf(currChar).matches(regex)){//运算符
                 if (index < i) {
                     infixOfArrayList.add(infix.substring(index,i));//add数字
                 }
                 infixOfArrayList.add(String.valueOf(currChar));
                 index = i+1;
             }
         }
         infixOfArrayList.add(infix.substring(index,length));
         return infixOfArrayList.toArray(new String[infixOfArrayList.size()]);
     }
     public static String[]  getPostfix(String infix) {
         String[] infixOfAry = preDeal(infix);
         int length = infixOfAry.length;
         ArrayDeque<String> stack = new ArrayDeque<String>();
         String currString = "";
         final String regex = "\\+|-|\\*|\\/|\\(|\\)";
         ArrayList<String> postfixOfArrayList = new ArrayList<String>();
         for (int i = 0; i < length; i++) {
             currString = infixOfAry[i];
             if (currString.matches(regex)) {//symbol
                 if (currString.matches("\\*|\\/|\\(")) {
                     stack.offerFirst(currString);
                 }else {//),+,-
                     String top = "";
                     if(currString.equals(")")){
                         while(!stack.isEmpty()){
                             top = stack.removeFirst();
                             if (top.equals("(")) {
                                 break;
                             }
                             postfixOfArrayList.add(top);
                         }
                     }else {//+ ,-
                         if (!stack.isEmpty()) {
                             top = stack.peekFirst();
                             if (top.equals("*") || top.equals("/")) {
                                 while(!stack.isEmpty()){
                                     postfixOfArrayList.add(stack.removeFirst());
                                 }
                             }
                         }
                         stack.offerFirst(currString);
                     }
                 }
             }else {//number
                 postfixOfArrayList.add(currString);
             }
         }
         while(!stack.isEmpty()){
             postfixOfArrayList.add(stack.removeFirst());
         }
         return postfixOfArrayList.toArray(new String[postfixOfArrayList.size()]);
     }
     public static double computePostfix(String infix){
         String[] postfixAry = getPostfix(infix);
         ArrayDeque<Double> stack = new ArrayDeque<Double>();
         int length = postfixAry.length;
         String currString = "";
         final String regex = "\\+|-|\\*|\\/|\\(|\\)";
         double operandOne,operandTwo;
         for (int i = 0; i < length; i++) {
             currString = postfixAry[i];
             if (currString.matches(regex)) {
                 operandOne = stack.removeFirst();
                 operandTwo = stack.removeFirst();
                 switch (currString.charAt(0)) {
                 case '+':
                     stack.addFirst(operandTwo + operandOne);
                     break;
                 case '-':
                     stack.addFirst(operandTwo - operandOne);
                     break;
                 case '*':
                     stack.addFirst(operandTwo * operandOne);
                     break;
                 case '/':
                     stack.addFirst(operandTwo / operandOne);
                     break;
                 }

             }else {
                 stack.addFirst(Double.parseDouble(currString));
             }
         }
         return stack.removeFirst();
     }
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         try {
             String infix = "100+8*5-(10/2)*5+10.5";
             double result = computePostfix(infix);
             System.out.println(result);
         } catch (Exception e) {
             // TODO: handle exception
             e.printStackTrace();
         }
     }

 }

（完）

转载请注明原文出处：http://www.cnblogs.com/qcblog/p/7502666.html