java 四则运算 栈的实现

• 博客分类： 
• java
• Algorithm

java 四则运算 栈的实现

 

Java代码  

1. import java.util.Stack;  
2. /**   
3.  * 利用栈，进行四则运算的类   
4.  * 用两个栈来实现算符优先，一个栈用来保存需要计算的数据numStack,一个用来保存计算优先符priStack   
5.  *    
6.  * 基本算法实现思路为：用当前取得的运算符与priStack栈顶运算符比较优先级：若高于，则因为会先运算，放入栈顶；   
7.  * 若等于，因为出现在后面，所以会后计算，所以栈顶元素出栈，取出操作数运算；   
8.  *  若小于，则同理，取出栈顶元素运算，将结果入操作数栈。各个优先级'(' > '*' = '/' > '+' = '-' > ')'   
9.  *    
10.  */      
11. public class Operate {      
12.     private Stack<Character> priStack = new Stack<Character>();// 操作符栈      
13.     private Stack<Integer> numStack = new Stack<Integer>();;// 操作数栈      
14.       
15.     /**   
16.      * 传入需要解析的字符串，返回计算结果(此处因为时间问题，省略合法性验证)   
17.      * @param str 需要进行技术的表达式   
18.      * @return 计算结果   
19.      */      
20.     public int caculate(String str) {      
21.         // 1.判断string当中有没有非法字符      
22.         String temp;// 用来临时存放读取的字符      
23.         // 2.循环开始解析字符串，当字符串解析完，且符号栈为空时，则计算完成      
24.         StringBuffer tempNum = new StringBuffer();// 用来临时存放数字字符串(当为多位数时)      
25.         StringBuffer string = new StringBuffer().append(str);// 用来保存，提高效率      
26.       
27.         while (string.length() != 0) {      
28.             temp = string.substring(0, 1);      
29.             string.delete(0, 1);      
30.             // 判断temp，当temp为操作符时      
31.             if (!isNum(temp)) {      
32.                 // 1.此时的tempNum内即为需要操作的数，取出数，压栈，并且清空tempNum      
33.                 if (!"".equals(tempNum.toString())) {      
34.                     // 当表达式的第一个符号为括号      
35.                     int num = Integer.parseInt(tempNum.toString());      
36.                     numStack.push(num);  
37.                     tempNum.delete(0, tempNum.length());      
38.                 }      
39.                 // 用当前取得的运算符与栈顶运算符比较优先级：若高于，则因为会先运算，放入栈顶；若等于，因为出现在后面，所以会后计算，所以栈顶元素出栈，取出操作数运算；      
40.                 // 若小于，则同理，取出栈顶元素运算，将结果入操作数栈。      
41.       
42.                 // 判断当前运算符与栈顶元素优先级，取出元素，进行计算(因为优先级可能小于栈顶元素，还小于第二个元素等等，需要用循环判断)      
43.                 while (!compare(temp.charAt(0)) && (!priStack.empty())) {   
44.                     int a = (int) numStack.pop();// 第二个运算数      
45.                     int b = (int) numStack.pop();// 第一个运算数      
46.                     char ope = priStack.pop();      
47.                     int result = 0;// 运算结果      
48.                     switch (ope) {      
49.                     // 如果是加号或者减号，则      
50.                     case '+':      
51.                         result = b + a;      
52.                         // 将操作结果放入操作数栈      
53.                         numStack.push(result);      
54.                         break;      
55.                     case '-':      
56.                         result = b - a;      
57.                         // 将操作结果放入操作数栈      
58.                         numStack.push(result);      
59.                         break;      
60.                     case '*':      
61.                         result = b * a;      
62.                         // 将操作结果放入操作数栈      
63.                         numStack.push(result);      
64.                         break;      
65.                     case '/':      
66.                         result = b / a;// 将操作结果放入操作数栈      
67.                         numStack.push(result);      
68.                         break;      
69.                     }      
70.       
71.                 }      
72.                 // 判断当前运算符与栈顶元素优先级， 如果高，或者低于平，计算完后，将当前操作符号，放入操作符栈      
73.                 if (temp.charAt(0) != '#') {      
74.                     priStack.push(new Character(temp.charAt(0)));      
75.                     if (temp.charAt(0) == ')') {// 当栈顶为'('，而当前元素为')'时，则是括号内以算完，去掉括号      
76.                         priStack.pop();      
77.                         priStack.pop();      
78.                     }      
79.                 }      
80.             } else      
81.                 // 当为非操作符时（数字）      
82.                 tempNum = tempNum.append(temp);// 将读到的这一位数接到以读出的数后(当不是个位数的时候)      
83.         }      
84.         return numStack.pop();      
85.     }      
86.       
87.     /**   
88.      * 判断传入的字符是不是0-9的数字   
89.      *    
90.      * @param str   
91.      *            传入的字符串   
92.      * @return   
93.      */      
94.     private boolean isNum(String temp) {      
95.         return temp.matches("[0-9]");      
96.     }      
97.       
98.     /**   
99.      * 比较当前操作符与栈顶元素操作符优先级，如果比栈顶元素优先级高，则返回true，否则返回false   
100.      *    
101.      * @param str 需要进行比较的字符   
102.      * @return 比较结果 true代表比栈顶元素优先级高，false代表比栈顶元素优先级低   
103.      */      
104.     private boolean compare(char str) {      
105.         if (priStack.empty()) {      
106.             // 当为空时，显然 当前优先级最低，返回高      
107.             return true;      
108.         }      
109.         char last = (char) priStack.lastElement();      
110.         // 如果栈顶为'('显然，优先级最低，')'不可能为栈顶。      
111.         if (last == '(') {      
112.             return true;      
113.         }      
114.         switch (str) {      
115.         case '#':      
116.             return false;// 结束符      
117.         case '(':      
118.             // '('优先级最高,显然返回true      
119.             return true;      
120.         case ')':      
121.             // ')'优先级最低，      
122.             return false;      
123.         case '*': {      
124.             // '*/'优先级只比'+-'高      
125.             if (last == '+' || last == '-')      
126.                 return true;      
127.             else      
128.                 return false;      
129.         }      
130.         case '/': {      
131.             if (last == '+' || last == '-')      
132.                 return true;      
133.             else      
134.                 return false;      
135.         }      
136.             // '+-'为最低，一直返回false      
137.         case '+':      
138.             return false;      
139.         case '-':      
140.             return false;      
141.         }      
142.         return true;      
143.     }      
144.       
145.     public static void main(String args[]) {      
146.         Operate operate = new Operate();      
147.         int t = operate.caculate("(3+4*(4*10-10/2)#");        
148.         System.out.println(t);      
149.     }      
150.       
151. }      

转自：http://justsee.iteye.com/blog/1125174