java 中缀式转后缀式

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

转载于:https://www.cnblogs.com/ikobe621/archive/2013/03/31/2991329.html