逆波兰计算器

1. 中缀表达式

　　我们在数学中学到的表达式被称为中缀表达式，操作符号在操作数中间，比如 2 + 3 * (5 - 1)。对人类而言，这种表达方式显而易见，求值也很直接，先算乘除再算加减，先算括号内再算括号外。

　　然而，这个表达式对于计算机而言却很费解。你可能会有疑问：这有什么难理解的嘛，在JavaScript、Python或者Ruby，甚至是Java里面都可以通过eval_r('2 + 3 * (5 - 1)')来计算这个表达式。当然，这里的计算机并不是指现而今强大的计算机和高级编程语言，而是指上个世纪中页还处于发展初期的计算机。

2. 后缀表达式

　　后缀表达式也称为逆波兰式（Reverse Polish Notation, RPN），更加广为人知一些，和前缀表达式刚好相反，是将操作符号放置于操作数之后，比如2 + 3 * (5 - 1)用逆波兰式来表示则是：2 3 5 1 - * +。

3.中缀表达式到后缀表达式的转换

　　因为通过后缀表达式来进行计算只需要一个栈即可，从硬件和软件上实现都是极为便利的，因此逆波兰式在计算机领域的应用更加广泛，因此将中缀表达式转换为逆波兰式非常重要。

使用栈就可以将中缀表达式转换成逆波兰式，转换过程如下：

　　从左往右遍历中缀表达式中的每个数字和符号，弱是数字就输出，成为逆波兰式的一部分； 如果是右括号，或者是其他符号并且比当前栈顶符号的优先级低，则栈顶元素依次出栈并输出； 然后将当前符号进栈，重复以上操作直到结束。

4.逆波兰表达式的计算

　　逆波兰式的计算是从左往右依次读取，当读到操作符时，将之前的两个操作数做计算，然后替换这两个操作数和操作符，接着读取，重复此步骤。对于这个表达式，读到5 1 -，得到4，然后读取乘号，取出前面的3和上一步的计算结果4，并计算，到12，接着读取加号+，计算2 12 +得到14，计算结束。

上面这个步骤可以很容易的用栈来实现：

　　从左往右依次读取表达式，如果是数字则将该数字压栈，如果是符号，则将之前的两个数字出栈，做计算后，将计算结果压栈，直到表达式读取结束。栈中剩下的一个数就是计算结果。

召唤代码~

主函数：

import java.util.Scanner;
import java.util.Stack;
import java.util.ArrayList;

public class RealCalc
{
static double op1=0, op2=0;
static Stack<Object> calcStack = new Stack<>(); //用于表达式转换和计算
static ArrayList<String> exp = new ArrayList<>(); //用于存储逆波兰表达式

public static void main(String[] args)
{
Scanner in = new Scanner(System.in);

double result = 0;
String expression = in.nextLine();
String e = expression;

tranfser(expression);
// printExp(); //调试用到的函数
result = compute();
if(String.valueOf(result).equals("Infinity"))
System.out.println("The divisor cannot be zero !");
else System.out.println(e+" = "+result);
}
}

函数一：中缀表达式转换成逆波兰表达式

//实质就是对字符串的一系列操作，把字符串转换成想要的形式
public static void tranfser(String expression)
{
char[] arr = expression.toCharArray();

for(int i=0; i < arr.length; i++)
{
if(isNum(arr[i]) || (i==0&&arr[i]=='-'))
{
/*
*这部分代码的作用是提取输入的算术表达式（中缀表达式）中的
*有效数字，包括整数.浮点数和负数。
*/
int index=0;
for(index=i+1; index<arr.length; index++)
{
if(isOperator(arr[index]) || arr[index]=='(' || arr[index]==')')
break;
}
exp.add(String.valueOf(arr, i, index-i));
i = index-1; //减 1 是因为 for 循环里 i 还会自增 1
}
else if(isOperator(arr[i]))
{
if(calcStack.empty())
calcStack.push(arr[i]);
else
{
if(operatorPriority(arr[i]) >= operatorPriority(calcStack.peek()))
calcStack.push(arr[i]);
else
{
for(int j=1; j<= calcStack.size(); j++)
exp.add(calcStack.pop().toString());
calcStack.push(arr[i]);
}
}
}
else if(arr[i] == '(')
{
calcStack.push(arr[i]);
if(arr[i+1] == '-')
{
int index=0;
for(index=i+2; index<arr.length; index++)
{
if(isOperator(arr[index]) || arr[index]==')')
break;
}
exp.add( String.valueOf(arr, i+1, index-(i+1)) ); //i-1 是因为不包括左括号
i = index-1; //减 1 是因为 for 循环里 i 还会自增 1
}
}
else if(arr[i] == ')')
{
int len = calcStack.size();
for(int k=1; k<=len ; k++)
{
if(calcStack.peek().toString().equals("("))
{
calcStack.pop();
break;
}
exp.add(calcStack.pop().toString());
}
}
}
if(!calcStack.empty())
{
int len = calcStack.size();
for(int i=0; i< len; i++)
exp.add(calcStack.pop().toString());
}
}

函数二：计算逆波兰表达式

public static double compute()
{
double temp = 0;

for(String atom : exp)
{
if(isNum(atom))
calcStack.push(atom);
else if(isOperator(atom))
{
op1 = Double.parseDouble(calcStack.pop().toString());
op2 = Double.parseDouble(calcStack.pop().toString());
//JDK7的新特性可以直接对字符串字面量switch()-case
switch(atom)
{
case "+": temp = op2+op1;break;
case "-": temp = op2-op1;break;
case "*": temp = op2*op1;break;
case "/": temp = op2/op1;break;
}
calcStack.push(temp);
}
}
return Double.parseDouble(calcStack.pop().toString());
}

其它的辅助函数：

//判断字符是否是阿拉伯数字
public static boolean isNum(Object o)
{
Character c = (Character)o;
return (c>='0' && c<='9')?true:false;
}//判断字符串是否是有效数字
public static boolean isNum(String s)
{
/*
*这个函数的思路还是蛮有意思的（可能对我这个新手来说，比较新奇），
*搜索了很多如何判断字符串是有效的数字，大多数都是利用正则表达式（可是我还没学到~尴尬）。
*经过群友的点拨，想到可以通过捕捉NumberFormatException来判断！
*/
try{
Double.parseDouble(s);
return true;
}catch(NumberFormatException e){
return false;
}
}
//判断字符是否是运算符
public static boolean isOperator(Object o)
{
Character c = (Character)o;
String s = "+-*/";
if(s.indexOf(c) != -1)
return true;
return false;
}//判断字符串是否是运算符
public static boolean isOperator(String s)
{
String operator = "+-*/";
if(operator.indexOf(s)!=-1)
return true;
return false;
}
//设置运算符的优先级
public static int operatorPriority(Object o)
{
Character c = (Character)o;
switch(c)
{
case '+': return 1;
case '-': return 1;
case '*': return 2;
case '/': return 2;
default: return 0;
}
}

//测试函数，打印exp（最后结果不对，就打印一下转换得到的逆波兰表达式，看看是否转换时就已经有问题了）
public static void printExp()
{
for(String s : exp)
System.out.println(s);
}