java中应用Stack进行算术运算的操作

2023-07-04 21:46:08 341

java.util.stack，继承自Vector

FILO,适合带有小括号的算术运算

importjava.util.Stack;
/**
*利用栈，进行四则运算的类
*用两个栈来实现算符优先，一个栈用来保存需要计算的数据numStack,一个用来保存计算优先符priStack
*
*基本算法实现思路为：用当前取得的运算符与priStack栈顶运算符比较优先级：若高于，则因为会先运算，放入栈顶；
*若等于，因为出现在后面，所以会后计算，所以栈顶元素出栈，取出操作数运算；
*若小于，则同理，取出栈顶元素运算，将结果入操作数栈。各个优先级'('>'*'='/'>'+'='-'>')'
*
*/
publicclassOperate{
privateStackpriStack=newStack();//操作符栈
privateStacknumStack=newStack();;//操作数栈

/**
*传入需要解析的字符串，返回计算结果(此处因为时间问题，省略合法性验证)
*@paramstr需要进行技术的表达式
*@return计算结果
*/
publicintcaculate(Stringstr){
//1.判断string当中有没有非法字符
Stringtemp;//用来临时存放读取的字符
//2.循环开始解析字符串，当字符串解析完，且符号栈为空时，则计算完成
StringBuffertempNum=newStringBuffer();//用来临时存放数字字符串(当为多位数时)
StringBufferstring=newStringBuffer().append(str);//用来保存，提高效率

while(string.length()!=0){
temp=string.substring(0,1);
string.delete(0,1);
//判断temp，当temp为操作符时
if(!isNum(temp)){
//1.此时的tempNum内即为需要操作的数，取出数，压栈，并且清空tempNum
if(!"".equals(tempNum.toString())){
//当表达式的第一个符号为括号
intnum=Integer.parseInt(tempNum.toString());
numStack.push(num);
tempNum.delete(0,tempNum.length());
}
//用当前取得的运算符与栈顶运算符比较优先级：若高于，则因为会先运算，放入栈顶；若等于，因为出现在后面，所以会后计算，所以栈顶元素出栈，取出操作数运算；
//若小于，则同理，取出栈顶元素运算，将结果入操作数栈。

//判断当前运算符与栈顶元素优先级，取出元素，进行计算(因为优先级可能小于栈顶元素，还小于第二个元素等等，需要用循环判断)
while(!compare(temp.charAt(0))&&(!priStack.empty())){
inta=(int)numStack.pop();//第二个运算数
intb=(int)numStack.pop();//第一个运算数
charope=priStack.pop();
intresult=0;//运算结果
switch(ope){
//如果是加号或者减号，则
case'+':
result=b+a;
//将操作结果放入操作数栈
numStack.push(result);
break;
case'-':
result=b-a;
//将操作结果放入操作数栈
numStack.push(result);
break;
case'*':
result=b*a;
//将操作结果放入操作数栈
numStack.push(result);
break;
case'/':
result=b/a;//将操作结果放入操作数栈
numStack.push(result);
break;
}

}
//判断当前运算符与栈顶元素优先级，如果高，或者低于平，计算完后，将当前操作符号，放入操作符栈
if(temp.charAt(0)!='#'){
priStack.push(newCharacter(temp.charAt(0)));
if(temp.charAt(0)==')'){//当栈顶为'('，而当前元素为')'时，则是括号内以算完，去掉括号
priStack.pop();
priStack.pop();
}
}
}else
//当为非操作符时（数字）
tempNum=tempNum.append(temp);//将读到的这一位数接到以读出的数后(当不是个位数的时候)
}
returnnumStack.pop();
}

/**
*判断传入的字符是不是0-9的数字
*
*@paramstr
*传入的字符串
*@return
*/
privatebooleanisNum(Stringtemp){
returntemp.matches("[0-9]");
}

/**
*比较当前操作符与栈顶元素操作符优先级，如果比栈顶元素优先级高，则返回true，否则返回false
*
*@paramstr需要进行比较的字符
*@return比较结果true代表比栈顶元素优先级高，false代表比栈顶元素优先级低
*/
privatebooleancompare(charstr){
if(priStack.empty()){
//当为空时，显然当前优先级最低，返回高
returntrue;
}
charlast=(char)priStack.lastElement();
//如果栈顶为'('显然，优先级最低，')'不可能为栈顶。
if(last=='('){
returntrue;
}
switch(str){
case'#':
returnfalse;//结束符
case'(':
//'('优先级最高,显然返回true
returntrue;
case')':
//')'优先级最低，
returnfalse;
case'*':{
//'*/'优先级只比'+-'高
if(last=='+'||last=='-')
returntrue;
else
returnfalse;
}
case'/':{
if(last=='+'||last=='-')
returntrue;
else
returnfalse;
}
//'+-'为最低，一直返回false
case'+':
returnfalse;
case'-':
returnfalse;
}
returntrue;
}

publicstaticvoidmain(Stringargs[]){
Operateoperate=newOperate();
intt=operate.caculate("(3+4*(4*10-10/2)#");
System.out.println(t);
}

}

补充：javastack实现的中缀简单四则运算表达式计算

我就废话不多说了，大家还是直接看代码吧~

publicabstractclassStack{
publicabstractbooleanisEmpty();
publicabstractbooleanisFull();
publicabstractTtop();
publicabstractbooleanpush(Tx);
publicabstractTpop();
publicabstractvoidclear();
}

publicclassSeqStackextendsStack{
privateObject[]elementData;
privateintmaxTop;
privateinttop;
publicSeqStack(intsize){
this.maxTop=size-1;
elementData=newObject[size];
top=-1;
}
@Override
publicbooleanisEmpty(){
returntop==-1;
}
@Override
publicbooleanisFull(){
returntop==maxTop-1;
}
@SuppressWarnings("unchecked")
@Override
publicTtop(){
if(top==-1){
System.out.println("Empty");
returnnull;
}
return(T)elementData[top];
}
@Override
publicbooleanpush(Tx){
if(top==maxTop){
System.err.println("Full");
returnfalse;
}
elementData[++top]=x;
returntrue;
}
@SuppressWarnings("unchecked")
@Override
publicTpop(){
if(top==-1){
System.err.println("Empty");
returnnull;
}

Tresult=(T)elementData[top];
elementData[top]=null;//gc
top--;
returnresult;
}
@Override
publicvoidclear(){

//letgcdoitswork
for(inti=0;i
publicclassStackCalc{
privateSeqStackstack;
publicStackCalc(intmaxSize){
stack=newSeqStack(maxSize);
}
privatevoidpushOperand(Integernumber){
stack.push(number);
}
privateNumberdoOperate(charoper){
Integerright=stack.pop();
Integerleft=stack.pop();
Integerresult=null;
if(left!=null&&right!=null){
switch(oper){
case'+':
result=left.intValue()+right.intValue();
break;
case'-':
result=left.intValue()-right.intValue();
break;
case'*':
result=left.intValue()*right.intValue();
break;
case'/':
if(right.intValue()==0){
System.err.println("Divideby0");
}
result=left.intValue()/right.intValue();
break;
default:
break;
}
}
stack.push(result);
returnresult;
}
privateinticp(charc){
switch(c){
case'#':
return0;
case'(':
return7;
case'*':
return4;
case'/':
return4;
case'+':
return2;
case'-':
return2;
case')':
return1;
default:
return-1;
}
}
privateintisp(intc){
switch(c){
case'#':
return0;
case'(':
return1;
case'*':
return5;
case'/':
return5;
case'+':
return3;
case'-':
return3;
case')':
return7;
default:
return-1;
}
}
publicStringtransfer(Stringexpression){
StringBuildersb=newStringBuilder();
SeqStackstack=newSeqStack(expression.length());
stack.push('#');
for(inti=0;iisp(stack.top())){//进栈
stack.push(c);
}else{//出栈
if(c==')'){
charch=stack.pop();
while(ch!='('){
sb.append(ch);
ch=stack.pop();
}
}else{
charch=stack.pop();
while(icp(c)<=isp(ch)){
sb.append(ch);
ch=stack.pop();
}
stack.push(ch);
stack.push(c);
}
}
}
}//endoffor
charch=stack.pop();
while(ch!='#'){

sb.append(ch);
ch=stack.pop();
}
stack.clear();
returnsb.toString();
}
publicIntegercalc(Stringexpression){
expression=transfer(expression);
for(inti=0;i
以上为个人经验，希望能给大家一个参考，也希望大家多多支持毛票票。如有错误或未考虑完全的地方，望不吝赐教。
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

java中应用Stack进行算术运算的操作

热门推荐

随机推荐