百度软件开发笔试大题3

对表达式求值。已知运算符只有加减乘除，无负数，结果也不是负数。（类似逆波兰法的算法思路）

思想：对数字只要入栈就可以，需要时拿出来计算。对符号，有几种情况：

（1）新符号加入前符号栈中还没有符号，则直接入栈；

（2）新符号是加减运算，则将之前符号栈中的符号全部拿出来计算，每次消耗1个符号，2个数字，再将得到的结果压入数字栈；

（3）新符号是乘除，之前的符号也是乘除，则只需要消耗一个符号就行；

（4）新符号乘除，原来符号加减，则符号压栈即可。

 

Eg. 1+4*5+2*3，定义两个栈分别存数字和符号，叫numStack和sigStack。

1）数字"1"入栈numStack；

2）因栈中还没有符号，符号"+"进栈sigStack;

3）数字"4"进栈numStack；

4）"*"属于乘除，而栈顶是加减，所以直接入栈sigStack；

5）5直接进栈numStack；

6）新符号加减运算，意味着之前的运算都可以完成，顺序是：5，4分别出栈，*出栈，4*5=20入栈numStack，然后20，1分别出栈，+出栈，

1+20=21入栈numStack，从而numStack只留下21，sigStack为空，然后"+"入栈sigStack；

7）2入栈numStack;

8）新符号*，栈顶符号+，直接入栈；

9）3入栈。

至此所有元素已经处理完毕，接下来就可以消耗所有的符号了，顺序是：2，3出栈，*出栈，3*2=6入栈，6，21出栈，+出栈，21+6=27得到结果。

 

下面是Java实现代码：

package preTest;

import java.util.Scanner;
import java.util.Stack;

public class Main3 {
    public static Stack sigStack = new Stack();//for char
    public static Stack numStack = new Stack();//for int
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            String str = in.nextLine();
            int result = cal(str);
            System.out.println(result);
        }
    }
    public static int cal(String str){
        sigStack.clear();
        numStack.clear();
        StringBuilder sb = new StringBuilder();
        int len = str.length();
        int result= 0;
        //完成数字和符号的压栈
        for(int i=0; i<len;i++){
            char c = str.charAt(i);
            //数字
            if(c>='0' && c <='9'){
                sb.append(c);
                if(i==len-1){
                    int x = Integer.parseInt((sb.toString()));
                    numStack.push(x);
                }
            }else{
                int x = Integer.parseInt((sb.toString()));
                numStack.push(x);
                sb.replace(0, sb.length(), "");
                if(sigStack.size() == 0){
                    sigStack.push(c);
                }else{
                    char existed = (char)sigStack.peek();
                    //如果已经压栈的符号优先级>=当前符号c，则完成压栈符号的操作
                    if(c=='+' || c=='-'){
                        zhengli();
                        sigStack.push(c);
                        //当两个都是乘除运算时
                    }else if(existed =='*' || existed == '/'){
                        tinyAdjust(c);
                    }else{//新符号乘除，旧符号加减
                        sigStack.push(c);
                    }    
                }
            }
        }
        //计算结果
        zhengli();
        result = (int)numStack.pop();
        return result;    
    }
    
    //简单加减乘除计算
    public static int compute(int a, int b, char c){
        int result = 0;
        switch(c){
        case '+': result = a+b;
            break;
        case '-': result = a-b;
            break;
        case '*': result = a*b;
            break;
        case '/': result = a/b;
            break;
        }
        return result;
    }
    
    //完全消化已经压栈的符号,用于新符号是加减时
    public static void zhengli(){
        while(sigStack.size() > 0){
            int a = (int)numStack.pop();
            int b = (int)numStack.pop();
            char c = (char)sigStack.pop();
            int x = compute(b,a,c);
            numStack.push(x);
        }
    }
    
    //消化一个符号,用于连续两个加减乘除符号出现时
    public static void tinyAdjust(char c){
        int x1 = (int)numStack.pop();
        int x2 = (int)numStack.pop();
        int x3 = compute(x2, x1,(char)sigStack.pop());
        numStack.push(x3);
        sigStack.push(c);
    }

}