笔试题：编程计算一个字符串类型的四则运算表达式的值

JebySin 2011-06-06 02:16:54
昨天下午去面试了一家利用JavaSE平台开发软件的公司，进门就让在电脑上做一套测试题，电脑不能上网。磨了两个小时后交卷走了，那套题做得不理想，估计没指望了。现在把题拿来和大家分享交流一下。
其中有一道编程题，题目如下：
编程计算一个字符串类型的四则运算表达式的值（暂不考虑有括号的情况），如：1+2*3-4/2
当时我只把大概的思路写了。回家后，整理了下，把代码写了出来，现在贴出来，希望和大家分享交流。各位有什么好的思路或者建议，欢迎发表意见。


/**

 * 问题:

 *     编写算法实现计算一个包含加减乘除四则运算的字符串表达式的值（暂不考虑括号）。例如：2+5*4-6/2

 * 思路：

 *     整个表达式分四趟运算，一趟计算乘法，二趟计算除法，三趟计算加法，四趟计算减法。

 *     每一趟从头开始截取一个最简表达式（两个数和一个运算符）运算，将运算结果放回表达式原位置，然后再截取计算，这个过程递归进行。

 * @author Jeby

 *

 */

public class Arithmetic {



	/**

	 * @param args

	 */

	public static void main(String[] args) {

		String ex = "0.5+2*4-2.5*4/5";

		System.out.println(ex+" = "+complete(ex));

	}

	

	public static double complete(String args) {

		String strResult = "";

		char[] operators = {'*','/','+','-'}; 

		for(int i=0;i<operators.length;i++) {

			strResult = subComplete(args,operators[i]);

			args = strResult;

		}

		return Double.parseDouble(strResult);

	}

	

	public static String subComplete(String args,char opera) {

		int operateIndex = 0;               //运算符索引

		int temp = 0;                       //临时变量，存放索引值

		double a = 0d;                      //数值a

		double b = 0d;                      //数值b

		String beforeOperaString = "";      //运算符之前的字符串

		String afterOperaString = "";       //运算符之后的字符串

		String strNumA = "";                //字符串类型的数字a

		String strNumB = "";                //字符串类型的数字b

		String strLeft = "";                //正在计算的最简表达式左边的串

		String strRight = "";               //正在计算的最简表达式右边的串

		String result = "";                 //运算结果（运算结果=最简表达式之前的字符串+最简表达式的值+最简表达式之后的字符串）

		

		operateIndex = args.indexOf(opera);

		if(operateIndex==-1) {

			return args;

		}

		//以运算符为界将字符串分为两节

		beforeOperaString = args.substring(0, operateIndex);           

		afterOperaString = args.substring(operateIndex+1);               

		//取出运算符两边的数，并得到正在计算的最简表达式左右两边的表达式串       

		temp = findCharIndex(beforeOperaString,false);

		strNumA= beforeOperaString.substring(temp==0?temp:temp+1);      

		if(temp!=0) {

			strLeft = beforeOperaString.substring(0, temp+1);     

		}

		temp = findCharIndex(afterOperaString,true);

		strNumB = afterOperaString.substring(0, temp==0?afterOperaString.length():temp);      

		if(temp!=0) {

			strRight = afterOperaString.substring(temp);         

		}

		a = Double.parseDouble(strNumA);

		b = Double.parseDouble(strNumB);

		if(opera=='*') result = strLeft+(a*b)+strRight;

		else if(opera=='/') result = strLeft+(a/b)+strRight;

		else if(opera=='+') result = strLeft+(a+b)+strRight;

		else if(opera=='-') result = strLeft+(a-b)+strRight;

		//打印

		System.out.println(result);

		return subComplete(result,opera);

	}

	/**

	 * 获取一个表达式中第一个或者最后一个运算符的索引值

	 * @param str - 被检查的字符串

	 * @param fromBegin - 如果true，用index查找最简表达式右边第一个运算符；

	 *                    如果false，用lastIndex查找最简表达式左边边最后一个运算符。

	 * @return 运算符索引

	 */

	public static int findCharIndex(String str,boolean fromBegin) {

		int index = 0;

		int temp = 0;

		if(fromBegin) {

			temp = str.indexOf('*');

			index = (temp!=-1)?temp:index;

			temp = str.indexOf('/');

			index = (temp!=-1 && (index==0 || temp<index))?temp:index;

			temp = str.indexOf('+');

			index = (temp!=-1 && (index==0 || temp<index))?temp:index;

			temp = str.indexOf('-');

			index = (temp!=-1 && (index==0 || temp<index))?temp:index;

			return index;

		}

		temp = str.lastIndexOf('*');

		index = (temp!=-1)?temp:index;

		temp = str.lastIndexOf('/');

		index = (temp!=-1 && (index==0 || temp>index))?temp:index;

		temp = str.lastIndexOf('+');

		index = (temp!=-1 && (index==0 || temp>index))?temp:index;

		temp = str.lastIndexOf('-');

		index = (temp!=-1 && (index==0 || temp>index))?temp:index;

		return index;

	}

	

}

程序运行结果：
0.5+8.0-2.5*4/5
0.5+8.0-10.0/5
0.5+8.0-2.0
8.5-2.0
6.5
0.5+2*4-2.5*4/5 = 6.5
...全文
3917 35 打赏 收藏 转发到动态 举报
写回复
用AI写文章
35 条回复
切换为时间正序
请发表友善的回复…
发表回复
mcb渣 2014-01-06
  • 打赏
  • 举报
 回复
我这代码行吗？ for(i=1;;) { c=getchar(); if(c=='\n') break;//如果按回车则结束输入 cin>>m; if(c=='+') { a[i]=m; i++; } if(c=='-') { a[i]=-m; i++; } if(c=='*') a[i-1]=a[i-1]*m; if(c=='/') { if(m==0)//如果分母为0，则提示输入错误，flags1=1，表示不输出结果 { cout<<"输入错误!请重新输入！"<<endl; flags1=1; break; } else a[i-1]=a[i-1]/m; } } if(m!=0)//如果不是因为分母为0正常结束的话，求表达式的值 { for(sum=0,j=0;j<i;j++) { sum=sum+a[j]; } }
妹妹 2011-09-13
  • 打赏
  • 举报
 回复
是额，应该是先把表达式化作逆波兰式（后缀表达式），然后压栈处理，
比如：
(a+b)*c的逆波兰式为ab+c*，假设计算机把ab+c*按从左到右的顺序压入栈中，并且按照遇到运算符就把栈顶两个元素出栈，执行运算，得到的结果再入栈的原则来进行处理，那么ab+c*的执行结果如下： 　　1）a入栈（0位置） 　　2）b入栈（1位置） 　　3）遇到运算符“+”，将a和b出栈，执行a+b的操作，得到结果d=a+b，再将d入栈（0位置） 　　4）c入栈（1位置） 　　5）遇到运算符“*”，将d和c出栈，执行d*c的操作，得到结果e，再将e入栈（0位置） 　　经过以上运算，计算机就可以得到(a+b)*c的运算结果e了。

[Quote=引用 1 楼 exesp 的回复:]
这个题记得IE上面也有人遇过，在面淘宝的吧
2个思路：
1.正则表达式
2.栈
[/Quote]
qiuwentianmingxin 2011-06-10
  • 打赏
  • 举报
 回复
* 获取一个表达式中第一个或者最后一个运算符的索引值
* @param str - 被检查的字符串
* @param fromBegin - 如果true，用index查找最简表达式右边第一个运算符；
* 如果false，用lastIndex查找最简表达式左边边最后一个运算符。
* @return 运算符索引
*/
public static int findCharIndex(String str,boolean fromBegin) {
int index = 0;
int temp = 0;
if(fromBegin) {
temp = str.indexOf('*');
index = (temp!=-1)?temp:index;
temp = str.indexOf('/');
index = (temp!=-1 && (index==0 || temp<index))?temp:index;
temp = str.indexOf('+');
index = (temp!=-1 && (index==0 || temp<index))?temp:index;
temp = str.indexOf('-');
index = (temp!=-1 && (index==0 || temp<index))?temp:index;
return index;
}
temp = str.lastIndexOf('*');
index = (temp!=-1)?temp:index;
temp = str.lastIndexOf('/');
index = (temp!=-1 && (index==0 || temp>index))?temp:index;
temp = str.lastIndexOf('+');
index = (temp!=-1 && (index==0 || temp>index))?temp:index;
temp = str.lastIndexOf('-');
index = (temp!=-1 && (index==0 || temp>index))?temp:index;
return index;
}

}

这里有出错没有逻辑思想
杰必尚 2011-06-09
  • 打赏
  • 举报
 回复
[Quote=引用 31 楼 micsolaris 的回复:]

Java code

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test{
public static void main(String[] args){
String result = compute("3*4-2*4-3*4+……
[/Quote]
终于等来了正则表达式……强。
micsolaris 2011-06-08
  • 打赏
  • 举报
 回复 


import java.util.regex.Matcher;   

import java.util.regex.Pattern;   

  

public class Test{   

    public static void main(String[] args){   

        String result = compute("3*4-2*4-3*4+5.5");   

        System.out.println(result);   

    }   

  

    public static String compute(String expression){   

        expression = "(" + expression + ")";   

        String regex = "(.*?)(\\([^()]+\\))(.*)";   

        Pattern pattern = Pattern.compile(regex);   

        Matcher matcher = pattern.matcher(expression);   

  

        while(matcher.find()){   

            expression = matcher.group(1) + compute1(matcher.group(2)) + matcher.group(3);   

            matcher = pattern.matcher(expression);   

           // System.out.println(expression);   

        }   

  

        return expression;   

    }   

  

    private static String compute1(String expression){   

        /*  

        计算没有包含括号的情况下的结果  

        */  

        expression = expression.replaceAll("[( )]","");   

        String regex = "^(.*?)(\\d+(?:\\.\\d+)?)([/*])(-?\\d+(?:\\.\\d+)?)(.*)";   

        Pattern pattern = Pattern.compile(regex);   

        Matcher matcher = pattern.matcher(expression);   

  

        double value1 = 0.0;   

        double value2 = 0.0;   

  

        String temp = null;   

  

        while(matcher.find()){   

            value1 = Double.valueOf(matcher.group(2));   

            value2 = Double.valueOf(matcher.group(4));   

            if(matcher.group(3).equals("*")){   

                temp = (value1 * value2) + "";   

            }else{   

                temp = (value1 / value2) + "";   

            }   

  

  

            expression = matcher.group(1) + temp + matcher.group(5);   

            expression = expression.replaceAll("--","+");   

            matcher = pattern.matcher(expression);   

        }   

  

        //System.out.println(expression);   

  

        regex = "^(.*?)((?:(?=[-+*/])-)?\\d+(?:\\.\\d+)?)([-+])(-?\\d+(?:\\.\\d+)?)(.*)";   

        pattern = Pattern.compile(regex);   

        matcher = pattern.matcher(expression);   

  

        while(matcher.find()){   

               

            value1 = Double.valueOf(matcher.group(2));   

               

            value2 = Double.valueOf(matcher.group(4));   

  

            if(matcher.group(3).equals("+")){   

                temp = (value1 + value2) + "";   

            }else{   

                temp = (value1 - value2) + "";   

            }   

  

            expression = matcher.group(1) + temp + matcher.group(5);   

            matcher = pattern.matcher(expression);   

        }   

  

        expression = expression.replaceAll("\\+","");   

  

        return expression;   

    }   

}
micsolaris 2011-06-08
  • 打赏
  • 举报
 回复
可以算负数、小数、括号


import java.util.regex.Matcher;   

import java.util.regex.Pattern;   

  

public class Test{   

    public static void main(String[] args){   

        String result = compute("3*4-2*4-3*4+5.5");   

        //System.out.println(result);   

    }   

  

    public static String compute(String expression){   

        expression = "(" + expression + ")";   

        String regex = "(.*?)(\\([^()]+\\))(.*)";   

        Pattern pattern = Pattern.compile(regex);   

        Matcher matcher = pattern.matcher(expression);   

  

        while(matcher.find()){   

            expression = matcher.group(1) + compute1(matcher.group(2)) + matcher.group(3);   

            matcher = pattern.matcher(expression);   

            System.out.println(expression);   

        }   

  

        return expression;   

    }   

  

    private static String compute1(String expression){   

        /*  

        计算没有包含括号的情况下的结果  

        */  

        expression = expression.replaceAll("[( )]","");   

        String regex = "^(.*?)(\\d+(?:\\.\\d+)?)([/*])(-?\\d+(?:\\.\\d+)?)(.*)";   

        Pattern pattern = Pattern.compile(regex);   

        Matcher matcher = pattern.matcher(expression);   

  

        double value1 = 0.0;   

        double value2 = 0.0;   

  

        String temp = null;   

  

        while(matcher.find()){   

            value1 = Double.valueOf(matcher.group(2));   

            value2 = Double.valueOf(matcher.group(4));   

            if(matcher.group(3).equals("*")){   

                temp = (value1 * value2) + "";   

            }else{   

                temp = (value1 / value2) + "";   

            }   

  

  

            expression = matcher.group(1) + temp + matcher.group(5);   

            expression = expression.replaceAll("--","+");   

            matcher = pattern.matcher(expression);   

        }   

  

        //System.out.println(expression);   

  

        regex = "^(.*?)((?:(?=[-+*/])-)?\\d+(?:\\.\\d+)?)([-+])(-?\\d+(?:\\.\\d+)?)(.*)";   

        pattern = Pattern.compile(regex);   

        matcher = pattern.matcher(expression);   

  

        while(matcher.find()){   

               

            value1 = Double.valueOf(matcher.group(2));   

               

            value2 = Double.valueOf(matcher.group(4));   

  

            if(matcher.group(3).equals("+")){   

                temp = (value1 + value2) + "";   

            }else{   

                temp = (value1 - value2) + "";   

            }   

  

            expression = matcher.group(1) + temp + matcher.group(5);   

            matcher = pattern.matcher(expression);   

        }   

  

        expression = expression.replaceAll("\\+","");   

  

        return expression;   

    }   

}
zqfddqr 2011-06-08
  • 打赏
  • 举报
 回复
[Quote=引用 2 楼 zhangao0086 的回复:]
不知道符不符合题意：
Java code

package cn.zhangao;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class TestCalString {

……
[/Quote]呵呵 估计不让你用
CoffeeStyle 2011-06-08
  • 打赏
  • 举报
 回复
跟2楼的大哥学了两个新类
安卓机器人 2011-06-08
  • 打赏
  • 举报
 回复
以上算法统统有问题
比如：3*4-2*4-3*4+5
算出的结果是21
杰必尚 2011-06-08
  • 打赏
  • 举报
 回复
不好意思，各位，我今天吃饭的时候才发现，原来我的代码是错误的，思路都错了！不能先算乘法，然后除法，接着加法，最后减法。因为照那种思路，计算2+4/2*2结果为3，很明显错误！
这个题最经典的求解就是后缀表达式（又名：逆波兰式），不熟悉的朋友快去研究一下吧。
安卓机器人 2011-06-08
  • 打赏
  • 举报
 回复
哈哈，好帖子，学到了不少东西
WJL_MGQS 2011-06-08
  • 打赏
  • 举报
 回复
学习。。。
cuiyanlei2010 2011-06-07
  • 打赏
  • 举报
 回复
[Quote=引用 13 楼 hudie1234567 的回复:]
http://blog.csdn.net/hudie1234567/archive/2010/09/18/5892175.aspx
这是去年自己写的一个，用的是栈！
[/Quote]
经典的栈用法，赞一个，学习了。
前方 2011-06-07
  • 打赏
  • 举报
 回复
关注中。学习中
hbprotoss 2011-06-07
  • 打赏
  • 举报
 回复
化成后缀表达式不就完了？
pl3121605999 2011-06-06
  • 打赏
  • 举报
 回复
[Quote=引用 2 楼 zhangao0086 的回复:]

不知道符不符合题意：
Java code

package cn.zhangao;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class TestCalString {

public ……
[/Quote]
这个学习了。。。以前确实不知道还有这样的用法！

我写的代码：


public class Test {



    public static void main(String[] args)  {

        String ex = "0.5+2*4-2.5*4/5";

        System.out.println(c(ex));

    }

    

    public static String c(String ex){

    	

    	char[] ch={'*','/','+','-'};

    for (int j = 0; j < 4; j=j+2) {

    	System.out.println();

       for (int i = 0; i < ex.length(); i++) {

        	if(ch[j]==ex.charAt(i)||ch[j+1]==ex.charAt(i)){

        		  int b = i;

        		  String temp="";

        		  String temp2="";

        		while(b>0){

        			b--;

        			if(ex.charAt(b)!='*'&&ex.charAt(b)!='/'&&ex.charAt(b)!='+'&&ex.charAt(b)!='-'){

                           temp+=   ex.charAt(b);

        			}else{

        				break;

        			}

        		}

        		

        		temp = fanZhuan(temp);

        		

        		b = i;

        		while(b<ex.length()-1){

        			b++;

        			if(ex.charAt(b)!='*'&&ex.charAt(b)!='/'&&ex.charAt(b)!='+'&&ex.charAt(b)!='-'){

        				temp2+= ex.charAt(b);

        			}else{

        				break;

        			}

        		}

        		if(!temp.matches("[\\d]+[\\.]?[\\d]*"))temp2 = fanZhuan(temp2);

        		

        		switch (ex.charAt(i)) {

				case '*':

					ex = ex.replace(temp+ch[j]+temp2, String.valueOf(Float.valueOf(temp)*Float.valueOf(temp2)));

					break;

				case '/':

					ex = ex.replace(temp+ch[j+1]+temp2, String.valueOf(Float.valueOf(temp)/Float.valueOf(temp2)));

					break;

				case '+':

					ex = ex.replace(temp+ch[j]+temp2, String.valueOf(Float.valueOf(temp)+Float.valueOf(temp2)));

					break;

				case '-':

					ex = ex.replace(temp+ch[j+1]+temp2, String.valueOf(Float.valueOf(temp)-Float.valueOf(temp2)));

					break;

				}

        		if(ex.matches("[\\d]+[\\.]?[\\d]*")){

        			break;

        		}else{

        			i=0;

        		}

        	}

		}

       }

                          return ex;

    }

    

    static String fanZhuan(String str){

    	

    	String temp = "";

    	

    	for (int i = str.length()-1; i >=0; i--) {

			 

    		temp+=str.charAt(i);

		}

    	return temp;

    }

    

}
TKD03072010 2011-06-06
  • 打赏
  • 举报
 回复
有考虑括号的情况：


import java.util.*;



public class CalExpression {



	// 整体运算

	private double calculate(String total) {

		int position1 = 0;

		int position2 = 0;



		// 分析表达式是否有括号

		Boolean had = false;



		for (int i = 0; i < total.length(); i++) {

			if (total.charAt(i) == '(')

				had = true;

		}



		// 查一下为什么indexof在此不能用~~~~谁知道的话告诉一声，下列代码错在哪里~~~



		// 用错这里 查了一小时菜查出错误



		if (had == true)// 只需处理第一个括号，然后递归调用自身，有括号继续处理，没括号就得果



		{

			for (int i = 0; i < total.length(); i++) {

				if (total.charAt(i) == '(') {

					position1 = i;

					continue;

				}

				if (total.charAt(i) == ')') {

					position2 = i;

					break;

				}

			}

			// 这句重点，有点长



			return calculate(total.substring(0, position1).trim()

					+ calculate(total.substring(position1 + 1, position2)

							.trim())

					+ total.substring(position2 + 1, total.length()).trim());



		} else

			return returnInner(total);

	}



	// 针对括号内的运算,即未带括号的表达式~~~有的话递归调用自身

	private double returnInner(String expression) {

		double result = 0;

		int op1 = 0;

		int op2 = 0;

		char operator = ' ';

		int count = 0;



		// 此循环用于获得前两个操作符的位置

		for (int i = 0; i < expression.length(); i++) {

			operator = expression.charAt(i);

			if (operator == 42 || operator == 43 || operator == 45

					|| operator == 47) {

				if (count == 0) {

					op1 = i;

					count++;

					continue;

				}

				if (count == 1) {

					op2 = i;

					break;

				}

			}

		}



		// 判断第一个操作符，并用递归计算整个表达式~~~~~



		// 即把未带括号的表达式拆成第一个数与其后面的表达式 进行运算

		// 这整个算法很经典~~~~呵呵~~有参考网上的解析~~~觉得这个最短最好用

		// 当然，括号太多~~仔细辨清各个整体~~~



		operator = expression.charAt(op1);

		if (operator == '+') {

			result = Double.parseDouble(expression.substring(0, op1).trim());// 获取第一个数

			if (op2 > 0)

				result += returnInner(expression.substring((op1 + 1),

						expression.length()));// 有两个以上操作符~~~递归

			else

				result += Double.parseDouble(expression.substring(op1 + 1,

						expression.length()).trim());// 只有一个+号

		} else if (operator == '-') // 同+运算

		{

			result = Double.parseDouble(expression.substring(0, op1).trim());

			if (op2 > 0)

				result -= returnInner(expression.substring((op1 + 1),

						expression.length()));

			else

				result -= Double.parseDouble(expression.substring(op1 + 1,

						expression.length()).trim());

		} else if (operator == '*') {

			if (op2 > 0)// 有两个以上操作符，先第一个数*第二个数 然后在与后面的字符组成一个表达式，带入递归 有用空格特意局开整体

				result = returnInner((Double.parseDouble(expression.substring(

						0, op1).trim()) * Double.parseDouble(expression

						.substring((op1 + 1), op2)))

						+ expression.substring(op2, expression.length()));

			else

				result = (Double.parseDouble(expression.substring(0, op1)

						.trim()) * Double.parseDouble(expression.substring(

						(op1 + 1), expression.length())));

			return result;

		} else if (operator == '/') // 同*运算

		{

			if (op2 > 0)

				result = returnInner((Double.parseDouble(expression.substring(

						0, op1).trim()) / Double.parseDouble(expression

						.substring((op1 + 1), op2)))

						+ expression.substring(op2, expression.length()));

			else

				result = (Double.parseDouble(expression.substring(0, op1)

						.trim()) / Double.parseDouble(expression.substring(

						(op1 + 1), expression.length())));

		}



		return result;

	}



	public static void main(String[] args) {

		System.out.println("Input the expression");// 手动输入表达式

		Scanner in = new Scanner(System.in);

		String exp = in.nextLine();

		CalExpression cal = new CalExpression();

		System.out.println(cal.calculate(exp));



	}

}
TKD03072010 2011-06-06
  • 打赏
  • 举报
 回复
[Quote=引用 13 楼 hudie1234567 的回复:]

http://blog.csdn.net/hudie1234567/archive/2010/09/18/5892175.aspx
这是去年自己写的一个，用的是栈！
[/Quote]
顶一下！！
要是引用javascript实现
方法很简单！！！
TheRealBo 2011-06-06
  • 打赏
  • 举报
 回复
就是中缀表达式转后缀表达式的问题
数据结构没学过？我有一个，不止有+-*/，还有加了三角函数等，你可参考一下,有不明之处可以pm我
import java.util.Stack;

import java.util.Stack;

public class Test{

	public static void TrnsInToSufix(String IFX,String []PFX)//PFX放后缀表达式，IFX为中缀表达式

    {

        StringBuffer numBuffer = new StringBuffer();// 用来保存一个数的

        Stack<String> s=new Stack<String>();//放操作符

        String a;

        s.push("=");//第一个为等号

        int i=0,j=0;

        char ch;

        for(i=0;i<IFX.length();)

        {

            ch=IFX.charAt(i);

            switch(ch)

            {

            case '0':case '1':case '2':

            case '3':case '4':case '5':

            case '6':case '7':case '8':

            case '9':

                while(Character.isDigit(ch)||ch=='.')//拼数

                    {

                    numBuffer.append(ch); // 追加字符

                    ch = IFX.charAt(++i);

                    }

                PFX[j++]=numBuffer.toString();//break; 

                numBuffer = new StringBuffer(); //清空已获取的运算数字

                  continue; //这里要重新循环，因为i已经增加过了

            case '(':

                s.push("(");break;

            case ')':

                while(s.peek()!="(")

                    PFX[j++]=s.pop();

                break;

            case '+':

            case '-':

                while(s.size()>1&&s.peek()!="(")

                    PFX[j++]=s.pop();

                a=String.valueOf(ch);

                s.push(a);break;

            case '*':

            case '/':

                while(s.size()>1&&(s.peek()=="*")||s.peek()=="/"

                	||s.peek()=="s"||s.peek()=="c"||s.peek()=="t"

                    ||s.peek()=="^"||s.peek()=="√")//优先级比较，与栈顶比较，

                    PFX[j++]=s.pop();//当前操作符优先级大于等于栈顶的弹出栈顶

                a=String.valueOf(ch);

                s.push(a);break;

            case 's':

            case 'c':

            case 't'://三角函数

            	while(s.size()>1&&(s.peek()=="s"||s.peek()=="c"||s.peek()=="t"

            		||s.peek()=="^"||s.peek()=="√"))//优先级比较，与栈顶，大于等于的弹出

            		PFX[j++]=s.pop();

            	a=String.valueOf(ch);

                s.push(a);break;

            case '^':// 幂

    		case '√':// 开方

    			while(s.size()>1&&(s.peek()=="^"||s.peek()=="√"))

    				PFX[j++]=s.pop();

            	a=String.valueOf(ch);

                s.push(a);break;		

            }

            i++; 

        }

        while(s.size()>1)

            PFX[j++]=s.pop();   

        PFX[j]="=";

    }

	public static String Evaluate (String []PFX)//后缀表达式求值

	{

		int i=0;

		double x1,x2,n;

		String str;

		Stack<String> s= new Stack<String>();

		while(PFX[i]!="=")

		{

			str=PFX[i];

			switch(str.charAt(0))

			{

			case '0':case '1':case '2':

			case '3':case '4':case '5':

			case '6':case '7':case '8':

			case '9':

				s.push(str);break;

			case '+':

				x1=Double.parseDouble(s.pop());

				x2=Double.parseDouble(s.pop());

				n=x1+x2;

				s.push(String.valueOf(n));break;

			case '-':

				x1=Double.parseDouble(s.pop());

				x2=Double.parseDouble(s.pop());

				n=x2-x1;

				s.push(String.valueOf(n));break;

			case '*':

				x1=Double.parseDouble(s.pop());

				x2=Double.parseDouble(s.pop());

				n=x1*x2;

				s.push(String.valueOf(n));break;

			case '/':

				x1=Double.parseDouble(s.pop());

				x2=Double.parseDouble(s.pop());

				n=x2/x1;

				s.push(String.valueOf(n));break;

			case 's':

				x1=Double.parseDouble(s.pop());

				n=Math.sin(x1 * Math.PI / 180);

				s.push(String.valueOf(n));break;

			case 'c':

				x1=Double.parseDouble(s.pop());

				n=Math.cos(x1 * Math.PI / 180);

				s.push(String.valueOf(n));break;

			case 't':

				x1=Double.parseDouble(s.pop());

				n=Math.tan(x1 * Math.PI / 180);

				s.push(String.valueOf(n));break;

			case '√':

				x1=Double.parseDouble(s.pop());

				n=Math.sqrt(x1);

				s.push(String.valueOf(n));break;// 开方

			case '^':

				x1=Double.parseDouble(s.pop());

				x2=Double.parseDouble(s.pop());

				n=Math.pow(x2, x1);

				s.push(String.valueOf(n));break; 

			}

			i++;

		}

		return s.pop();

	}

	 public static void main(String[] args) { 

	        Test eval = new StrTest(); 

	        String s="1+2*3=";//sin45*2,sin 要用string.replace转换成 s

	    	String[] PFX = new String[100];

			Test.TrnsInToSufix(s, PFX);

	        System.out.println(Test.Evaluate(PFX)); 

	        

	    } 

}
杰必尚 2011-06-06
  • 打赏
  • 举报
 回复
[Quote=引用 15 楼 wangjie1989091 的回复:]
面试题一般都会考算法，大概不会想到你会使用API。
这道题的典型做法是使用逆波兰式
[/Quote]
嗯，应该是考察算法功底
加载更多回复（15）
诺西笔试题
之前诺西让面试时发过来的一套题目，附有我自己的做的答案，不一定准确，可以参考下，注题目是英文的，希望能给面试的同行们有点帮忙，顺便自己挣点小分。
大华笔试题
大华笔试题
亚信科技笔试题-部分有答案
亚信笔试题，部分题目有答案
C语言笔试题（华为公司笔试题）
华为公司的一些C语言笔试题目，希望对正在找工作的朋友有一点点帮助咯！
.net笔试题及答案
个人收集的关于.net方面笔试的题目，主要是简答题，很少关于程序方面的题，差不多罗列了网上所能能找到的
Java SE

62,633

社区成员

307,289

社区内容

发帖
与我相关
我的任务
社区描述
Java 2 Standard Edition
社区管理员
  • Java SE
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章