双栈表达式求值算法:支持小数点,负数,括号,乘方运算

增加支持小数点、负数、括号、乘方运算。

    //双栈表达式求值算法
private String stackCalculate(String str){
    //记录小数点索引位置
    int dotIndex = 0;
    //记录是否存在负号
    boolean negative = false;

    Stack ops = new Stack();
    Stack vals = new Stack();
    if (!str.isEmpty()){
        for (int i = 0;i < str.length();i++) {
            String temp = String.valueOf(str.charAt(i));
            if (temp.equals("(")) {
                ;
            } else if (temp.equals("＋")) {
                ops.push("+");
            } else if (temp.equals("－")) {
                ops.push("-");
            } else if (temp.equals("×")) {
                ops.push("*");
            } else if (temp.equals("÷")) {
                ops.push("/");
            } else if (temp.equals("√")) {
                ops.push(temp);
            } else if (temp.equals("^")) {
                ops.push(temp);
            } else if (temp.equals(")")) {
                String rop = ops.pop();
                double v = vals.pop();
                if (rop.equals("+")) v = vals.pop() + v;
                else if (rop.equals("-")) v = vals.pop() - v;
                else if (rop.equals("*")) v = vals.pop() * v;
                else if (rop.equals("/")) v = vals.pop() / v;
                else if (rop.equals("√")) v = Math.sqrt(v);
                else if (rop.equals("^")) v = Math.pow(vals.pop(),v);
                vals.push(v);
            } else if (temp.equals("-")) {
                //存在负号
                negative = true;
            } else if (temp.equals(".")){
                //保存小数点索引
                dotIndex = i;
            } else {
                //处理小数
                if (dotIndex > 0){
                    double v = Integer.parseInt(temp) * Math.pow(10, -(i - dotIndex));
                    double p = vals.pop();
                    if (p < 0){
                        vals.push(-(-p + v));
                    } else {
                        vals.push(p + v);
                    }

                    if (i+1 < str.length()){
                        if (!Character.isDigit(str.charAt(i+1))){
                            if (negative == true){
                                double np = vals.pop();
                                vals.push(-np);
                                negative = false;
                            }
                            dotIndex = 0;
                        }
                    }
                    continue;
                }

                //若操作数栈不为空
                if (i-1 >= 0){
                    //操作多位数
                    if (Character.isDigit(str.charAt(i - 1))) {
                        int p = 0;
                        if (!vals.isEmpty()) {
                            p = vals.pop().intValue();
                        }
                        if (p < 0) {
                            p = -p;
                        }
                        double t = p * 10 + Integer.parseInt(temp);
                        if (negative == true) {
                            vals.push(-t);
                            if (i+1 < str.length()){
                                //下一位非数字
                                if (!Character.isDigit(str.charAt(i+1))){
                                    negative = false;
                                }
                                //已到达最后一个字符
                            } else {
                                negative = false;
                            }
                        } else {
                            vals.push(t);
                        }
                    //非多位数
                    } else {
                        if (negative == true){
                            vals.push(-Double.parseDouble(temp));
                            //不含小数点或已处理完小数点
                            if (dotIndex == 0){
                                if (i+1 < str.length()){
                                    //下一位非数字
                                    if (!Character.isDigit(str.charAt(i+1))){
                                        negative = false;
                                    }
                                    //已到达最后一个字符
                                } else {
                                    negative = false;
                                }
                            }
                        } else {
                            vals.push(Double.parseDouble(temp));
                        }
                    }
                //若操作数栈为空
                } else {
                    if (negative == true){
                        vals.push(-Double.parseDouble(temp));
                        //不含小数点或已处理完小数点
                        if (dotIndex == 0){
                            if (i+1 < str.length()){
                                //下一位非数字
                                if (!Character.isDigit(str.charAt(i+1))){
                                    negative = false;
                                }
                                //已到达最后一个字符
                            } else {
                                negative = false;
                            }
                        }
                    } else {
                        vals.push(Double.parseDouble(temp));
                    }
                }
            }
        }

        //最后，若表达式中不含括号，也要执行计算
        while (!ops.isEmpty() && !vals.isEmpty()){
            String rop = ops.pop();
            double v = vals.pop();
            if (rop.equals("+")) {
                v = vals.pop() + v;
            } else if (rop.equals("-")){
                v = vals.pop() - v;
            } else if (rop.equals("*")){
                v = vals.pop() * v;
            } else if (rop.equals("/")){
                v = vals.pop() / v;
            } else if (rop.equals("√")){
                v = Math.sqrt(v);
            } else if (rop.equals("^")){
                v = Math.pow(vals.pop(),v);
            }
            vals.push(v);
        }
    }
    return String.valueOf(vals.pop());
}

}