表达式求值

最新推荐文章于 2022-06-08 16:00:46 发布

原创最新推荐文章于 2022-06-08 16:00:46 发布 · 129 阅读

0 ·

CC 4.0 BY-SA版权

Javascript 专栏收录该内容

2 篇文章

订阅专栏

本文介绍了一种实现逆波兰表达式解析和计算的方法。通过定义运算符及其优先级，将输入的数学表达式转换成逆波兰形式，并计算其结果。文章详细展示了算法流程，包括如何处理括号和不同运算符的优先级。

var	 operate={
			'gcd':{fun:function(a,b){return b==0?a:arguments.callee(b,a%b);},precedence:9,isPrefix:true},
			'+u':{fun:function(a){return a;},precedence:9,isPrefix:true},
			'-u':{fun:function(a){return -a;},precedence:9,isPrefix:true},
			'+':{fun:function(a,b){return a+b;},precedence:6,isPrefix:false},
			'-':{fun:function(a,b){return a-b;},precedence:6,isPrefix:false},
			'*':{fun:function(a,b){return a*b;},precedence:8,isPrefix:false},
			'/':{fun:function(a,b){return a/b;},precedence:8,isPrefix:false}
			};
function getResult(){

	var input = document.myform.inputText.value
	var RPolishArray =[];
	RPolishArray = toRPolish(input);
	document.myform.RPolish.value = RPolishArray;
	var result = calculate(RPolishArray);
	document.myform.sunText.value = result;

}
/**
* 计算逆波兰表达式的值
*/

			
function calculate(RPolishArray){
	var item='';
	var stack =[];

	for(var i = 0;i < RPolishArray.length;i++){
		item=RPolishArray[i];
		if((/\d/).test(item)){
			
			stack.push(item*1);
		}else if(item in operate){
			var len=operate[item].fun.length;
			args=stack.splice(stack.length-len,len);
			stack.push(operate[item].fun.apply(null,args));
			}
	}	
	return stack.pop();
}

/**
* 把普通算术表达式转换为逆波兰表达式
*/
function toRPolish(input){   
    var token=null;
    isUnary=true;
 //   ([0-9]+|[*+-\/()])/
    var tokens=input.match(/(?![a-zA-Z_])\d+\.?\d*|[*+-\/(),]|\w+/g);
    var output = [];  
    var opStack = [];  
    for(var i = 0;i < tokens.length;i++){ 
	var lastToken=token;
	var token=tokens[i];
	if(isUnary){token=token=='-'?'-u':token; token=token=='+'?'+u':token;}
	isUnary=false;
        if(token.match(/\d+\.\d+|\d+/)){  

                output.push(token);  
 

        }  
	else  if(token=='('){  
			isUnary=true;
                        opStack.push(token);  
        }  
	else if(token==')'){  
                    while(opStack[opStack.length-1]!='('){  
                        if(opStack.length==0)throw("括号不匹配");
			output.push(opStack.pop());  

                    }  
                
		//    if(opStack[opStack.length-1]=='(' )
                      opStack.pop();
	}
	else if(token==','){  
                    while(opStack[opStack.length-1]!='('){  
                        if(opStack.length==0)throw("括号不匹配");
			output.push(opStack.pop());  

                    }  
                
	}	
	else if( token in operate){ 
		isUnary=true;
		
		while(opStack.length&&
			opStack[opStack.length-1]!='('&&
			(!operate[token].isPrefix && operate[token].precedence <= operate[opStack[opStack.length-1]].precedence ||
			operate[token].isPrefix && operate[token].precedence < operate[opStack[opStack.length-1]].precedence)
			){  
				output.push(opStack.pop());  
		}  
			opStack.push(token);
	}
	else {
		throw(token+"未定义此函数");
	
	}
                  

    }             
    while(opStack.length >0){  
        output.push(opStack.pop());  
    }  
 
    return output;  
}