后缀表达式的实现以及运算（附demo，有注释，复制了就能跑）

 

  不知道后缀表达式的可以先点这里看一看，非常有意思！

  
  不多比比，上代码！

public class NBLS {
    public static void main(String[] args) {
        String a = "1+2*3*5/6+4";
        char[] qs = qs(a);
        System.out.println(ys(qs));
    }

    //进行四则运算
    public static double szys(double a,double b,char c){
        switch(c){
            case '+' : return b + a;
            case '-' : return b - a;
            case '*' : return b * a;
            default : return b / a;
        }
    }
    //判断是否是运算符
    public static boolean ysf(char s) {
        if (!(s == '+' || s == '-' || s == '*' || s == '/')) {
            //char要是不是运算符就返回true，否则返回false
            return true;
        }
        return false;
    }

    //运算后缀表达式
    public static double ys(char[] s){
        Stack<Double> z = new Stack();
        double res=0;
        for (int i = 0; i < s.length; i++) {
            //是数字就进栈
            if(ysf(s[i])){
                z.push( (double)s[i]-48);
                continue;
            }
            //不是数字就从栈顶弹出两个元素进行运算
            Double a = z.pop();
            Double b = z.pop();
            res=szys(a,b,s[i]);
            z.push(res);
        }
        return res;
    }
    //转后缀表达式
    public static char[] qs(String s) {
        char[] chars = s.toCharArray();
        char[] res = new char[chars.length];
        Stack<Character> z = new Stack();
        int index = 0;
        for (int i = 0; i < chars.length; i++) {
            //是数字就直接输出
            if (ysf(chars[i])) {
                res[index] = chars[i];
                index++;
                continue;
            }
            //是+或者-的话就先与栈顶元素比较，如果栈顶元素优先级大于当前元素就输出栈中所有元素后，当前元素入栈
            if ((int) chars[i] == 43 || chars[i] == 45) {
                if (z.size() != 0) {
                    if ((int) z.peek() == 42 || (int) z.peek() == 47) {
                        while (z.size() != 0) {
                            res[index] = z.pop();
                            index++;
                        }
                        z.push(chars[i]);
                        continue;
                    }
                }
                z.push(chars[i]);
                continue;
            }
            //是*或者/的话直接入栈
            if ((int) chars[i] == 42 || chars[i] == 47) {
                z.push(chars[i]);
                continue;
            }

        }
        //当算式遍历完后栈中还有剩余元素直接输出
        if (z.size() != 0) {
            while (z.size() != 0) {
                res[index] = z.pop();
                index++;
            }
        }
        return res;
    }
}

  这个是不支持括号运算的，有兴趣的厚米可以自己动手加一下。