数据结构Java实现06----中缀表达式转换为后缀表达式

  1 /**
  2  * Created by smyhvae on 2015/9/7.
  3  * 工具类：
  4  * 1、中缀表达式转化为后缀表达式
  5  * 2、给出一个算术表达式（中缀表达式），直接得到计算结果
  6  */
  7 
  8 import java.util.Stack;
  9 import java.util.regex.Pattern;
 10 
 11 public class StringToArithmetic {
 12 
 13     private StringToArithmetic() {
 14     }
 15 
 16     //方法：给出一个算术表达式（中缀表达式），得到计算结果。 例如 (5+8+10)*1，返回23
 17     public static double stringToArithmetic(String string) {
 18         return suffixToArithmetic(infixToSuffix(string));
 19     }
 20 
 21     /**
 22      * 中缀表达式转后缀表达式 只处理了+,-,*,/和括号，没有处理负号及其它运算符，也没对前缀表达式验证。
 23      * 如要处理负号，可对表达式进行预转义处理，当下面条件成立时，将负号换成单目运算符"!" infix.charAt[i]=='-'&&(
 24      * i==0||infix.charAt[i-1]=='(')
 25      * 3*6/4+3
 26      * 3+6-4           3 6 + 4 -
 27      * 3+(6-4/2)*5    3 6 4 2 / - 5 * +
 28      */
 29     //方法：中缀表达式转成后缀表达式
 30     public static String infixToSuffix(String infix) {
 31         Stack<Character> stack = new Stack<Character>();
 32         String suffix = "";
 33         int length = infix.length();
 34         for (int i = 0; i < length; i++) {
 35             Character temp;
 36             char c = infix.charAt(i);
 37             switch (c) {
 38                 // 忽略空格
 39                 case ' ':
 40                     break;
 41                 // 碰到'('，push到栈
 42                 case '(':
 43                     stack.push(c);
 44                     break;
 45                 // 碰到'+''-'，将栈中所有运算符弹出，送到输出队列中
 46                 case '+':
 47                 case '-':
 48                     while (stack.size() != 0) {
 49                         temp = stack.pop();
 50                         if (temp == '(') {
 51                             stack.push('(');
 52                             break;
 53                         }
 54                         suffix += " " + temp;
 55                     }
 56                     stack.push(c);
 57                     suffix += " ";
 58                     break;
 59                 // 碰到'*''/'，将栈中所有乘除运算符弹出，送到输出队列中
 60                 case '*':
 61                 case '/':
 62                     while (stack.size() != 0) {
 63                         temp = stack.pop();
 64                         if (temp == '(' || temp == '+' || temp == '-') {
 65                             stack.push(temp);
 66                             break;
 67                         } else {
 68                             suffix += " " + temp;
 69                         }
 70                     }
 71                     stack.push(c);
 72                     suffix += " ";
 73                     break;
 74                 // 碰到右括号，将靠近栈顶的第一个左括号上面的运算符全部依次弹出，送至输出队列后，再丢弃左括号
 75                 case ')':
 76                     while (stack.size() != 0) {
 77                         temp = stack.pop();
 78                         if (temp == '(')
 79                             break;
 80                         else
 81                             suffix += " " + temp;
 82                     }
 83                     // suffix += " ";
 84                     break;
 85                 //如果是数字，直接送至输出序列
 86                 default:
 87                     suffix += c;
 88             }
 89         }
 90 
 91         //如果栈不为空，把剩余的运算符依次弹出，送至输出序列。
 92         while (stack.size() != 0) {
 93             suffix += " " + stack.pop();
 94         }
 95         return suffix;
 96     }
 97 
 98 
 99     /**
100      * postfix
101      *
102      * @return double
103      */
104     //方法：通过后缀表达式求出算术结果
105     public static double suffixToArithmetic(String postfix) {
106 
107         Pattern pattern = Pattern.compile("\\d+||(\\d+\\.\\d+)"); //使用正则表达式 匹配数字
108         String strings[] = postfix.split(" ");  //将字符串转化为字符串数组
109         for (int i = 0; i < strings.length; i++)
110             strings[i].trim();  //去掉字符串首尾的空格
111         Stack<Double> stack = new Stack<Double>();
112 
113         for (int i = 0; i < strings.length; i++) {
114 
115             if (strings[i].equals(""))
116                 continue;
117 
118             //如果是数字，则进栈
119             if ((pattern.matcher(strings[i])).matches()) {
120 
121                 stack.push(Double.parseDouble(strings[i]));
122             } else {
123                 //如果是运算符，弹出运算数，计算结果。
124                 double y = stack.pop();
125                 double x = stack.pop();
126                 stack.push(caculate(x, y, strings[i])); //将运算结果重新压入栈。
127             }
128         }
129         return stack.pop(); //弹出栈顶元素就是运算最终结果。
130 
131     }
132 
133     private static double caculate(double x, double y, String simble) {
134         if (simble.trim().equals("+"))
135             return x + y;
136         if (simble.trim().equals("-"))
137             return x - y;
138         if (simble.trim().equals("*"))
139             return x * y;
140         if (simble.trim().equals("/"))
141             return x / y;
142         return 0;
143     }
144 }

 1 public class Test {
 2     public static void main(String[] args) {
 3 
 4         String str = "3+(2-5)*6/3";  //其后缀表达式为325-6*3/+
 5 
 6         //调用方法：中缀表达式转成后缀表达式
 7         System.out.println(StringToArithmetic.infixToSuffix(str));
 8 
 9         //调用方法：给出一个算术表达式（中缀表达式），得到计算结果
10         System.out.println(StringToArithmetic.stringToArithmetic(str));
11 
12     }
13 
14 }