Go语言视频零基础入门到精通

javalearner

编写java程序时，我们可能会碰到解释数学表达式的问题，例如，输入字符串“(5+4)*10”，求出其算术结果，对于这个问题，可以通过后缀表达式来解决。 首先，让我们看看后缀表达式的算法：
1、将中缀表达式转换为后缀表达式： (1)当读到数字直接送至输出队列中；
(2)当读到运算符t时：
      a.将栈中所有优先级高于或等于t的运算符弹出，送到输出队列中；
  b.t进栈；
（3）读到左括号时总是将它压入栈中；
（4）读到右括号时，将靠近栈顶的第一个左括号上面的运算符全部依次弹出，送至输出队列后，再丢弃左括号；
（5）中缀表达式全部读完后，若栈中仍有运算符，将其送到输出队列中。

2、 运用后缀表达式进行计算：
(1)建立一个栈S；
(2)从左到右读后缀表达式，读到数字就将它转换为数值压入栈S中，读到运算符则从栈中依次弹出两个数分别到Y和X，然后以“X 运算符 Y”的形式计算机出结果，再压加栈S中；
(3)如果后缀表达式未读完，就重复上面过程，最后输出栈顶的数值则为结束。 例：
中缀表达式：3+(2-5)*6/3 转换为后缀表达式的过程：
  最后，后缀表达式为： 3 2 5 - 6 *3 /+ 代码：

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

复制代码

   
     
     
      
      

        
      

        
      
     
   

  


源码下载：http://file.javaxxz.com/2014/11/19/000955906.zip