前缀，中缀和后缀

package qmk.simple_test;
import java.util.Scanner;
import java.util.Stack;
/**
* Example of converting an infix-expression to
* Polish Notation (PN) or Reverse Polish Notation (RPN).
* Written in 2011-8-25
* @author QiaoMingkui
*/
public class Calculator {
public static final String USAGE = "== usage ==\n"
+ "input the expressions, and then the program "
+ "will calculate them and show the result.\n"
+ "input 'bye' to exit.\n";
/**
* @param args
*/
public static void main(String[] args) {
System.out.println(USAGE);
Scanner scanner = new Scanner(System.in);
String input = "";
final String CLOSE_MARK = "bye";
System.out.println("input an expression:");
input = scanner.nextLine();
while (input.length() != 0
&& !CLOSE_MARK.equals((input))) {
System.out.print("Polish Notation (PN):");
try {
toPolishNotation(input);
} catch (NumberFormatException e) {
System.out.println("\ninput error, not a number.");
} catch (IllegalArgumentException e) {
System.out.println("\ninput error:" + e.getMessage());
} catch (Exception e) {
System.out.println("\ninput error, invalid expression.");
}
System.out.print("Reverse Polish Notation (RPN):");
try {
toReversePolishNotation(input);
} catch (NumberFormatException e) {
System.out.println("\ninput error, not a number.");
} catch (IllegalArgumentException e) {
System.out.println("\ninput error:" + e.getMessage());
} catch (Exception e) {
System.out.println("\ninput error, invalid expression.");
}
System.out.println("input a new expression:");
input = scanner.nextLine();
}
System.out.println("program exits");
}
/**
* parse the expression , and calculate it.
* @param input
* @throws IllegalArgumentException
* @throws NumberFormatException
*/
private static void toPolishNotation(String input)
throws IllegalArgumentException, NumberFormatException {
int len = input.length();
char c, tempChar;
Stack<Character> s1 = new Stack<Character>();
Stack<Double> s2 = new Stack<Double>();
Stack<Object> expression = new Stack<Object>();
double number;
int lastIndex = -1;
for (int i=len-1; i>=0; --i) {
c = input.charAt(i);
if (Character.isDigit(c)) {
lastIndex = readDoubleReverse(input, i);
number = Double.parseDouble(input.substring(lastIndex, i+1));
s2.push(number);
i = lastIndex;
if ((int) number == number)
expression.push((int) number);
else
expression.push(number);
} else if (isOperator(c)) {
while (!s1.isEmpty()
&& s1.peek() != ')'
&& priorityCompare(c, s1.peek()) < 0) {
expression.push(s1.peek());
s2.push(calc(s2.pop(), s2.pop(), s1.pop()));
}
s1.push(c);
} else if (c == ')') {
s1.push(c);
} else if (c == '(') {
while ((tempChar=s1.pop()) != ')') {
expression.push(tempChar);
s2.push(calc(s2.pop(), s2.pop(), tempChar));
if (s1.isEmpty()) {
throw new IllegalArgumentException(
"bracket dosen't match, missing right bracket ')'.");
}
}
} else if (c == ' ') {
// ignore
} else {
throw new IllegalArgumentException(
"wrong character '" + c + "'");
}
}
while (!s1.isEmpty()) {
tempChar = s1.pop();
expression.push(tempChar);
s2.push(calc(s2.pop(), s2.pop(), tempChar));
}
while (!expression.isEmpty()) {
System.out.print(expression.pop() + " ");
}
double result = s2.pop();
if (!s2.isEmpty())
throw new IllegalArgumentException("input is a wrong expression.");
System.out.println();
if ((int) result == result)
System.out.println("the result is " + (int) result);
else
System.out.println("the result is " + result);
}
/**
* parse the expression, and calculate it.
* @param input
* @throws IllegalArgumentException
* @throws NumberFormatException
*/
private static void toReversePolishNotation(String input)
throws IllegalArgumentException, NumberFormatException {
int len = input.length();
char c, tempChar;
Stack<Character> s1 = new Stack<Character>();
Stack<Double> s2 = new Stack<Double>();
double number;
int lastIndex = -1;
for (int i=0; i<len; ++i) {
c = input.charAt(i);
if (Character.isDigit(c) || c == '.') {
lastIndex = readDouble(input, i);
number = Double.parseDouble(input.substring(i, lastIndex));
s2.push(number);
i = lastIndex - 1;
if ((int) number == number)
System.out.print((int) number + " ");
else
System.out.print(number + " ");
} else if (isOperator(c)) {
while (!s1.isEmpty()
&& s1.peek() != '('
&& priorityCompare(c, s1.peek()) <= 0) {
System.out.print(s1.peek() + " ");
double num1 = s2.pop();
double num2 = s2.pop();
s2.push(calc(num2, num1, s1.pop()));
}
s1.push(c);
} else if (c == '(') {
s1.push(c);
} else if (c == ')') {
while ((tempChar=s1.pop()) != '(') {
System.out.print(tempChar + " ");
double num1 = s2.pop();
double num2 = s2.pop();
s2.push(calc(num2, num1, tempChar));
if (s1.isEmpty()) {
throw new IllegalArgumentException(
"bracket dosen't match, missing left bracket '('.");
}
}
} else if (c == ' ') {
// ignore
} else {
throw new IllegalArgumentException(
"wrong character '" + c + "'");
}
}
while (!s1.isEmpty()) {
tempChar = s1.pop();
System.out.print(tempChar + " ");
double num1 = s2.pop();
double num2 = s2.pop();
s2.push(calc(num2, num1, tempChar));
}
double result = s2.pop();
if (!s2.isEmpty())
throw new IllegalArgumentException("input is a wrong expression.");
System.out.println();
if ((int) result == result)
System.out.println("the result is " + (int) result);
else
System.out.println("the result is " + result);
}
/**
* calculate the two number with the operation.
* @param num1
* @param num2
* @param op
* @return
* @throws IllegalArgumentException
*/
private static double calc(double num1, double num2, char op)
throws IllegalArgumentException {
switch (op) {
case '+':
return num1 + num2;
case '-':
return num1 - num2;
case '*':
return num1 * num2;
case '/':
if (num2 == 0) throw new IllegalArgumentException("divisor can't be 0.");
return num1 / num2;
default:
return 0; // will never catch up here
}
}
/**
* compare the two operations' priority.
* @param c
* @param peek
* @return
*/
private static int priorityCompare(char op1, char op2) {
switch (op1) {
case '+': case '-':
return (op2 == '*' || op2 == '/' ? -1 : 0);
case '*': case '/':
return (op2 == '+' || op2 == '-' ? 1 : 0);
}
return 1;
}
/**
* read the next number (reverse)
* @param input
* @param start
* @return
* @throws IllegalArgumentException
*/
private static int readDoubleReverse(String input, int start)
throws IllegalArgumentException {
int dotIndex = -1;
char c;
for (int i=start; i>=0; --i) {
c = input.charAt(i);
if (c == '.') {
if (dotIndex != -1)
throw new IllegalArgumentException(
"there have more than 1 dots in the number.");
else
dotIndex = i;
} else if (!Character.isDigit(c)) {
return i + 1;
} else if (i == 0) {
return 0;
}
}
throw new IllegalArgumentException("not a number.");
}

/**
* read the next number
* @param input
* @param start
* @return
* @throws IllegalArgumentException
*/
private static int readDouble(String input, int start)
throws IllegalArgumentException {
int len = input.length();
int dotIndex = -1;
char c;
for (int i=start; i<len; ++i) {
c = input.charAt(i);
if (c == '.') {
if (dotIndex != -1)
throw new IllegalArgumentException(
"there have more than 1 dots in the number.");
else if (i == len - 1)
throw new IllegalArgumentException(
"not a number, dot can't be the last part of a number.");
else
dotIndex = i;
} else if (!Character.isDigit(c)) {
if (dotIndex == -1 || i - dotIndex > 1)
return i;
else
throw new IllegalArgumentException(
"not a number, dot can't be the last part of a number.");
} else if (i == len - 1) {
return len;
}
}

throw new IllegalArgumentException("not a number.");
}
/**
* return true if the character is an operator.
* @param c
* @return
*/
private static boolean isOperator(char c) {
return (c=='+' || c=='-' || c=='*' || c=='/');
}
}


下面是程序运行结果（绿色为用户输入）：

== usage ==
input the expressions, and then the program will calculate them and show the result.
input 'bye' to exit.

input an expression:
3.8+5.3
Polish Notation (PN):+ 3.8 5.3
the result is 9.1
Reverse Polish Notation (RPN):3.8 5.3 +
the result is 9.1
input a new expression:
5*(9.1+3.2)/(1-5+4.88)
Polish Notation (PN):/ * 5 + 9.1 3.2 + - 1 5 4.88
the result is 69.88636363636364
Reverse Polish Notation (RPN):5 9.1 3.2 + * 1 5 - 4.88 + /
the result is 69.88636363636364
input a new expression:
1+((2+3)*4)-5
Polish Notation (PN):- + 1 * + 2 3 4 5
the result is 16
Reverse Polish Notation (RPN):1 2 3 + 4 * + 5 -
the result is 16
input a new expression:
bye
program exits