关于Java写逆波兰表达式堆栈操作简单实现
目的：
重新熟悉逆波兰表达式算法，通过Java实现逆波兰表达式从容更加深刻理解算法与编程之间的关系；重新熟悉堆栈，并用Java程序实现堆栈的操作。
验证方式：
图书馆查阅资料，手写计算逆波兰实现基本算法，电脑Java编程实现算法。
过程：
1. 通过读书，重新拾起逆波兰表达式算法的记忆，中缀表达式转化为后缀表达式，从而来实现计算器算法。
2. 中缀表达式转化为后缀表达式其实是运算表达式优先级的体现。
例：中缀表达式：1.a+b*c 2.(a+b)*c 3.(a+b*c)/(d-e)
后缀表达式：1.abc*+ 2.ab+c*3.abc*+de-/
由上例可以看出，优先级决定后缀表达式的书写。
3. 由具体算法实现逆波兰表达式：可建立两个堆栈，一个用来放置运算符（Sign），一个用来放置依次安排的后缀表达式（RPN）。A.如果进来的是数值，直接压到RPN中。B.如果进来的是‘（’，将它压入Sign。C.如果进来的是运算符：1.查看现在的Sign，如果它是‘（’，直接将运算符压入Sign；2如果不是，则看进来的运算符比Sign现在的顶部元素运算符的优先级是否更高，如果优先级高，将运算符压入Sign,如果不高于，则将Sign现在的顶部元素运算符取出压入到RPN中。C.如果进来的是‘）’，则在Sign中查找‘（’，并从Sign栈顶开始依次取出压入到RPN，直到找到‘（’，并将‘（’删除。
1. Java程序源码：
import java.util.Scanner;
public class shuzu_RPN {
private char[]list;//放置最开始输入的，被拆分之后的内容
private char[]sign;//放置运算符
private char[]rpnList;//放置逆波兰表达式
public staticvoidmain(String[] arge){
shuzu_RPNrpn= newshuzu_RPN();
//通过键盘输入要要操作的中缀表达式
rpn.getEquation();
//将中缀表达式转化为后缀表达式
rpn.setRPN();
//输出表达式结果
rpn.printResult();
}
//获得整个算数表达式
public voidgetEquation(){
System.out.println("请输入算数表达式：");
//键盘输入
Scannersc= newScanner(System.in);
Stringstr= sc.nextLine();
//获得输入内容后，将字符串内的空格都给消掉
str.replaceAll(" ", "");
//将输入的字符串转换成字符放在list数组中
list = new char[str.length()];
list = str.toCharArray();
//输出一遍
System.out.println("您输入的算数表达式是：");
for(int i = 0; i<list.length; i++){
System.out.print(list[i]);
}
System.out.println();
}
//读取list,转化为逆波兰表达式
public voidsetRPN(){
//创建一个字符，用来指针作用
char x;
//将两个字符数组的长度限定
sign = new char[list.length+1];
rpnList = new char[list.length+1];
//指符号数组top
sign[0] = '#';
/*在下面的运算中，rpn没加一个，rpnlen将指向下一位
而signlen指向的是当前sign的最高位*/
int signlen = 0;
//指rpn数组top
int rpnlen = 0;
for(int i = 0; i < list.length; i++){
//依次读取字符，进行判断
x = list[i];
switch(x){
case '(':
//符号位加1
signlen++;
sign[signlen] = x;
break;
case ')':
while(sign[signlen]!='('){
//依次将括号内容转入到rpnList中
rpnList[rpnlen] = sign[signlen];
//RPN加位
rpnlen++;
//运算符号位减位
signlen--;
}
//将‘（’设置为空
signlen--;
break;
//接下来是算数运算符，加减乘除，当后一个优先级不高于前一个优先级，不出
case '+':
case '-':
for(int j = signlen; j >= 0; j--){
//+-的运算优先级比*/的低
if(sign[j] == '('||signlen == 0){
break;
}else{
//直接将现在的栈顶元素搞到rpnList中
rpnList[rpnlen] = sign[j];
signlen--;
rpnlen++;
}
}
signlen++;
sign[signlen] = x;
break;
case '*':
case '/':
for(int j = signlen; j >= 0; j--){
//运算优先级，*/的运算优先级高于+-
if(sign[j] == '('||sign[j] == '+'||sign[j] == '-'||signlen == 0){
break;
}else{
//把现在的顶部运算符拿出来
rpnList[rpnlen] = sign[j];
signlen--;
rpnlen++;
}
}
signlen++;
sign[signlen] = x;
break;
//遇到非运算符
default:
rpnList[rpnlen] = x;
rpnlen++;
}
}
//当符号数组不为空，倒置放到rpn数组
while(signlen>0){
rpnList[rpnlen] = sign[signlen];
signlen--;
rpnlen++;
}
}
public voidprintResult(){
System.out.println("生成的逆波兰表达式：");
for(int i = 0; i < rpnList.length; i++){
System.out.print(rpnList[i]);
}
}
}
2. 运算结果：
请输入算数表达式：
((2+1)*(3-1))/(2-1)
您输入的算数表达式是：
((2+1)*(3-1))/(2-1)
生成的逆波兰表达式：
21+31-*21-/_
结果：
经过查阅资料，仔细验证，终于实现逆波兰表达式，并实现后进先出的堆栈。算法实现并不困难。最大的收获是及时发现自己出现的眼高手低的毛病。及时补漏，并以此为戒，是这次试验最大的收获。
这是很久之前写的一个简单的实现文档，没想到还留着.额...才疏学浅，请多多指教