java 逆波兰_逆波兰表达式算法-Java版

这两天一直在看数据结构，栈这个地方，基础的就是这个逆波兰表达式，看了很多博文，都讲得不清不楚或者只能计算一个位的数字，决定自己写，这篇博文给了很大启发–>Go New Land AND Here

逆波兰简而言之是将中缀转换为后缀表达式，从而方便计算机进行四则运算，属于栈的基本运用

操作符优先级： ()    +-     */%(从左到右递增)

规则：

1.建立一个OP(操作栈),一个ArrayList(存储输出结果)

2.将字符串从左向右遍历,把数据放入ArrayList,把运算符压入运算符的栈

关于运算符压栈的规则:

⑴ 如果OP为空或者为待压栈操作符为左括号则直接将运算符压入栈

⑵ 如果待压栈操作符的优先级大于栈顶操作符则直接入栈

⑶ 如果待压栈操作符的优先级小于栈顶操作符,则将OP栈顶的操作符依次输出 直到遇到左括号或者OP为空则停止,此时压入该操作符到OP栈顶中

⑷ 如果遇到右括号则将OP栈中的元素依次弹出 输出 直到遇到左括号为止，同时弹出左括号不放入ArrayList，并且右括号不压入OP

⑸ 最后将OP中的元素依次弹出输出, 将ArrayList输出则是最终的逆波兰表达式

JAVA代码：import java.util.ArrayList; import java.util.Stack;

/** * 将中缀表达式转出后缀表达式，再计算其结果 * 中缀表达式 9+(3-1)*3+10/2 = 20 转后缀931-3*+10 2/+ */

public class 栈逆波兰表达式 {

public static void toOpArray(String x) {

//存储输出的结果

ArrayList operate =new ArrayList();

//操作符的栈

Stack stack = new Stack();

//原始串

StringBuffer oldString=new StringBuffer();

char[] old = (x + " ").toCharArray();

StringBuffer stringBuffer = new StringBuffer();

for (char read : old) {

//原始操作符分割 数字和操作符的区分

if (read >= 48 && read <= 57) {

stringBuffer.append(read); continue;

} else {

if (stringBuffer.length() != 0) {

//存入数字操作符分隔好的原始表达式

oldString.append(stringBuffer+" ");

operate.add(Integer.valueOf(stringBuffer.toString())); stringBuffer.setLength(0);

}

}

//最后的空格不参与计算

if (read==' '){

continue;

}

//存入数字操作符分隔好的原始表达式

oldString.append(read+" ");

//解析 OP为操作栈

//⑴ 如果OP为空或者为待压栈操作符为左括号则直接将运算符压入栈

if (stack.isEmpty()||read=='('){

stack.push(read);

//结束此次运算符操作

continue;

}

//⑷ 如果遇到右括号则将OP栈中的元素依次弹出 输出至operate中直到遇到左括号为止，弹出左括号但不输出至operate 并且右括号不压入OP

if (read==')'){

//不为空则一直循环

while (!stack.isEmpty()){

char tmp= (char) stack.pop();

//当遇到左括号 弹出并结束循环

if (tmp=='('){

break;

}

//否则输出到operate中

operate.add(tmp);

}

continue;

}

//普通情况

if (!stack.isEmpty()){

char top= (char) stack.pop();

int readPri=getPriority(read);

int topPri=getPriority(top);

//⑵ 如果待压栈操作符的优先级大于栈顶操作符则直接入栈

if (readPri>topPri){

//不要忘记将弹出的压入

stack.push(top);

stack.push(read);

}else {

//⑶ 如果栈顶操作符的优先级大于待压栈操作符,则将OP栈顶的操作符依次输出

// 直到遇到左括号或者OP为空则停止,此时压入该操作符到OP栈顶中

operate.add(top);

while (true){

if (!stack.isEmpty()){

char tmp= (char) stack.pop();

if (tmp=='('){

stack.push(tmp);

break;

}

operate.add(tmp);

}else {

break;

}

}

stack.push(read);

}

}

}

//⑸ 最后将OP中的元素依次弹出并输出，则operate为最终的逆波兰表达式

while (!stack.isEmpty()){

operate.add(stack.pop());

}

//输出

System.out.println("原始串："+oldString);

System.out.print("结果串：");

for (int i = 0; i < operate.size(); i++) {

System.out.print(operate.get(i) + " ");

}

//计算结果

//getRes(operate);

System.out.println("\n");

}

//() +- */ 优先级从小到大

public static int getPriority(char read) {

int pri = -1;

switch (read) {

case '+': pri = 1; break;

case '-': pri = 1; break;

case '*': pri = 2; break;

case '/': pri = 2; break;

case '(': pri = 0; break;

case ')': pri = 0; break;

}

return pri;

}

public static void main(String[] args) {

System.out.println("理论串："+"9 3 1 - 3 * + 10 2 / +");

toOpArray("90+(3-1)*3+10/2");

toOpArray("9+10/2+(3-1)*3");

toOpArray("10/2+(3-1)*3+90");

}

}

//计算结果

private static void getRes(ArrayList operate) {

Stack stack=new Stack();

//因为我上面的逆波兰最后面带了一个空格 所以最后一个元素为空 不计算 这里减一

for (int i = 0; i

if (operate.get(i).equals('+')||operate.get(i).equals('-')

||operate.get(i).equals('*')||operate.get(i).equals('/')){

//操作符处理

char c= (char) operate.get(i);

int b= (int) stack.pop();

int a= (int) stack.pop();

switch (c){

case '+': stack.push(a+b); break;

case '-': stack.push(a-b); break;

case '*': stack.push(a*b); break;

case '/': stack.push(a/b); break;

}

} else {

//数字压栈

stack.push(operate.get(i));

}

}

System.out.println("结果为："+stack.pop());

System.out.println();

}

看了规则，写一遍代码，就可以理解了。

当然，我这个也没处理负数，没处理被除数为0的情况

大概思路：

负数：当遇到一个操作符() + – * / 第二次如果依旧为操作字符而且为-时 下个数字做负数处理

被除数为0：遇到/后，判断下个数字是否为0，为0则抛出异常

发现一个bug：(24*1+(4+6)*2) + (4-3*2)*(4+6-9+(11-3*4)*2+2)*10+20-3*2*4+2 会是1738

(24*1+(4+6)*2) 是44

(4-3*2)*(4+6-9+(11-3*4)*2+2)*10+20-3*2*4+2 是-22

没能找到原因，待高手指点。