中缀表达式转后缀并计算（只考虑个位整数，不考虑除0等情况）

中缀转后缀

public class 中缀转后缀 {
    static char[] res;//存储结果
    static int len_r=0;

    static char[] stack;//操作符栈
    static int len_s=0;

    public static String transfer(String s){
        res=new char[s.length()];
        stack=new char[s.length()];

        char[] ch=s.toCharArray();

        for(int i=0;i<ch.length;++i){
            //数字直接输出到结果
            if(ch[i]>='0'&&ch[i]<='9'){
                res[len_r++]=ch[i];
            }else{
                //右括号：操作符出栈输出到结果，直到遇到左括号（左括号出栈但不输出到结果）
                if(ch[i]==')'){
                    while(len_s>0&&stack[--len_s]!='('){
                        res[len_r++]=stack[len_s];
                    }
                }else{
                    //左括号直接进操作符栈
                    if(ch[i]=='('){
                        stack[len_s++]=ch[i];
                    }else{
                        //操作符出栈输出到结果，直到遇到自己的位置。
                        int index=getIndex(ch[i]);
                        while(len_s>index){
                            res[len_r++]=stack[--len_s];
                        }
                        stack[len_s++]=ch[i];
                    }
                }
            }
        }
        while(--len_s>=0){
            res[len_r++]=stack[len_s];
        }
        return new String(res,0,len_r);
    }
    /*
    * 如果是*或/，遇到(、+、-、空 进栈
    * 如果是+或-，遇到(、空 进栈
    * */
    static int getIndex(char ch){
        int index=0;
        boolean flag=true;
        if(ch=='+'||ch=='-'){
            flag=false;
        }
        for(int i=len_s-1;i>=0;--i){
            if(flag&&(stack[i]=='('||stack[i]=='+'||stack[i]=='-')){
                index=i+1;
                break;
            }
            if(!flag&&stack[i]=='('){
                index=i+1;
                break;
            }
        }
        return index;
    }
}

　　计算后缀表达式

public class 计算后缀表达式 {
    public static int doCompute(String s){
        char[] ch=s.toCharArray();
        int[] stack=new int[s.length()];
        int len=0;
        for(int i=0;i<ch.length;++i){
            //数字进栈；遇到操作符ch，出栈两个数a,b（a先出），把b ch a的结果进栈。最后输出栈顶元素。
            if(ch[i]>='0'&&ch[i]<='9'){
                stack[len++]=ch[i]-'0';
            }else{
                int a=stack[--len];
                int b=stack[--len];
                stack[len++]=compute(a,b,ch[i]);
            }
        }
        return stack[0];
    }
    static int compute(int b,int a,char ch){
        int res=0;
        switch(ch){
            case '+':
                res=a+b;
                break;
            case '-':
                res=a-b;
                break;
            case '*':
                res=a*b;
                break;
            case '/':
                res=a/b;
                break;
        }
        return res;
    }
}