四则运算表达式

说明：Stack,和StirngStack,是工具类，协助编程
convertPRN是将中缀表达式转为后缀表达式
RPN是计算后缀表达式的值
 
1 statck接口 
package DataStruct.Stack; 
public interface Stack { 
public void push(Object k); 
public Object pop(); 
public boolean isEmpty(); 
public boolean isFull(); 
  public Object peek(); 
} 
2  StringStack类 
package DataStruct.Stack.Sample; 
import DataStruct.Stack.*; 
public class StringStack implements Stack { 
private String[] s; 
private int top; 
private int MAX; 
public StringStack(int MAX) { 
  this.MAX = MAX; 
  s = new String[MAX]; 
  top = -1; 
} 
public boolean isEmpty() { 
  return (top == -1); 
} 
public boolean isFull() { 
  return (top == MAX - 1); 
} 
public void push(Object k) { 
  s[++top] = k.toString(); 
} 
public Object pop() { 
  return (Object) s[top--]; 
} 
public Object peek() { 
  return (Object) s[top]; 
} 
} 
3 RPN类  用来计算后缀表达式的值 
/* 
* 计算RPN表示式的值 
* RPN即为:逆波兰表达式reverse polish notation 
* RPN rpn=new RPN("AB+C*"); 
* RPN rpn=new RPN("9 8 + 2 *"); 
*/ 
package DataStruct.Stack.Sample; 
import DataStruct.Stack.*; 
public class RPN { 
private String express; 
public RPN(String express) { 
  this.express = express; 
} 
public int count() { 
  int result = 0;// 存放最终结果 
  int tr = 0;// 临时结果 
  Stack stack = new StringStack(100);// 构造一个栈 
  String[] s_array = express.split(" "); 
  String temp = null; 
  int p = 0; 
  int q = 0; 
  for (int i = 0; i < s_array.length; i++) { 
   temp = s_array[i].toString(); 
   // 如果是运算符计算 
   if (temp.equals("*") || temp.equals("/") || temp.equals("+") 
     || temp.equals("-")) { 
    p = Integer.parseInt(stack.pop().toString()); 
    q = Integer.parseInt(stack.pop().toString()); 
    char t = temp.charAt(0); 
    switch (t) { 
    case '*': 
     tr = p * q; 
     stack.push(String.valueOf(tr)); 
     break; 
    case '.': 
     tr = p / q; 
     stack.push(String.valueOf(tr)); 
     break; 
    case '+': 
     tr = p + q; 
     stack.push(String.valueOf(tr)); 
     break; 
    case '-': 
     tr = p - q; 
     stack.push(String.valueOf(tr)); 
     break; 
    } 
   } 
   // 否则入栈 
   else 
    stack.push(temp); 
  } 
  int r = Integer.parseInt(stack.pop().toString()); 
  return r; 
} 
public static void main(String[] args) { 
  RPN rpn = new RPN("9 8 + 2 *"); 
  int r = rpn.count(); 
  System.out.println(r); 
} 
} 
4 convertRPN 将中缀表达式转换为后缀表达式 
/*
 * 将中缀表达式转成RPN 
 * 将(9+8)*2转为"9 8 + 2 *"
 */
package DataStruct.Stack.Sample;
import DataStruct.Stack.*;
public class ConvertRPN {
 private String express;
 private StringBuffer sb;
 public ConvertRPN(String express) {
  this.express = express;
  sb = new StringBuffer();
 }
 // 将中缀转换成后缀
 public String convert() {
  Stack s = new StringStack(100);
  String temp = null;//
  String[] ee = express.split(" ");
  // 从左到右扫描字符串
  for (int i = 0; i < ee.length; i++) {
   temp = ee[i];
   // 如果为操作符
   if (temp.equals("*") || temp.equals("/") || temp.equals("+")
     || temp.equals("-") || temp.equals("(") || temp.equals(")")) {
    char c = temp.charAt(0);
    switch (c) {
    //如果是')'则将栈的内容弹出附加到表达式中，直到遇到'('为止，并将'('弹出
    case ')':
     while (!s.peek().equals("(")) {
      addResult(s.pop());
     }
     s.pop();
     break;
    //如果是运算符,
    //如果栈不为空，并栈顶内容不为'(',则比较该运算符和栈顶运算符的优先级，如果大于直接入栈，否则先取栈顶内容，再入栈。
    //否则，直接将运算符入栈
    case '+':
    case '-':
    case '*':
    case '/':
     if (!s.isEmpty() && !s.peek().equals("(")) {
      if (compare(c, s.peek().toString().charAt(0))) {
       s.push(temp);
      } else {
       addResult(s.pop());
       s.push(temp);
      }
     } else
      s.push(temp);
     break;
    //如果运算符为‘（’,直接入栈
    case '(':
     s.push(temp);
     break;
    }
   }
   // 如果是数值则直接放入到表达式中
   else {
    addResult(temp);
   }
  }
  //最后将栈中的运算符依次附加在表达式后
  while (!s.isEmpty()) {
   addResult(s.pop());
  }
  return new String(sb);
 }
 // 将对象追加到表示式中
 private void addResult(Object o) {
  sb.append(o);
  sb.append(" ");
 }
 // 比较运算符的优先级,如果小于等于则返回false,
 // 如果大于则返回true;
 private boolean compare(char a, char b) {
  if (a == '*' || a == '/') {
   if (b == '+' || b == '-')
    return true;
  }
  return false;
 }
 public static void main(String[] args) {
  ConvertRPN c = new ConvertRPN("( 9 - 3 ) * ( 2 - 1 )");
  System.out.println(c.convert());
 }
}