Question

您好我一直在研究我的Java计算器。它现在将所有操作数和运算符放在不同的数组中，并且我还有一个具有每个运算符优先级的数组。

For example * and / are 1 and + and - are 2.
So if my operator array holds '[/, +, +, *]'
My priority array holds '[1, 2, 2, 1]'

我坚持的部分是我现在需要确保我的计算器可以重新排序运算符，这样我就可以通过我的calculateResult并确保运算符的顺序正确。

我要求帮助的部分是计算结果。我无法弄清楚如何做到这一点，以便按正确的顺序计算它。

import java.util.*;
public class stringCalculator {

    //String containing the input from the user
    private String userinput;
    //List to store the operators in
    private ArrayList<String> calcOperator = new ArrayList<String>();
    //List to store the operands in
    private ArrayList<Integer> calcOperand = new ArrayList<Integer>();
    //Array to store all the integers in
    private String[] integers;
    //Array to store all the operators in
    private String[] operators;
    //Array to store the priority value
    private String[] priorityList;

    public stringCalculator(String userinput){
        this.userinput = userinput;
        //System.out.println(userinput);
        integers = userinput.split("[+-/*///]");
        operators = userinput.split("\\d+");
    }   

    //This function will check the input and return true if the user enters a correct expression.
    public boolean checkInput(){
        boolean show = userinput.matches("[-+/*0-9]+");
        return show;
    }

    //This function will add any numbers in the string to the calcOperand array.
    //and any operators to the calcOperator field.
    public void parseInput(String[] item){
        for (String op : item){
            if (op.matches("\\d+")){
                calcOperand.add(Integer.parseInt(op));
            }
            //operators go into calcOperators.
            else if (op.equals("+")||op.equals("-")||op.equals("*")||op.equals("/")){
                calcOperator.add(op);
            }
            else{//everything else is ignored and left. 
            }
        }
    }

    //Function to calculate the priority of each operator.
    //For example * and / will be 1, and + and - will be 2.
    public void calculatePriority(){
        priorityList = calcOperator.toArray(new String[calcOperator.size()]);
        for (int i = 0; i<priorityList.length; i++){
            if (priorityList[i].equals("+")){
                priorityList[i] = "2";
            }else if (priorityList[i].equals("-")) {
                    priorityList[i] = "2";
            }else if (priorityList[i].equals("/")){
                priorityList[i] = "1";
            }else if (priorityList[i].equals("*")){
                priorityList[i] = "1";
            }else{
                System.out.println("error");
            }
        }
    }
    public void printPri(){

        for (String s : priorityList)
            System.out.print(s +",");
    }

    //Function to show the result of the expression.
    public void calculateResult(){
        if(checkInput()){
            parseInput(integers);
            parseInput(operators);
            System.out.println("Operands: " + calcOperand);
            System.out.println("Operators: " + calcOperator);
            calculatePriority();
            System.out.print("Priority: ");
            printPri();
        }else{
            System.out.println("Please enter a valid input!");

        }
    }

}

Answer 1

执行此操作的正确方法是将输入解析为AST（抽象语法树）。然后以正确的顺序对表达式进行评估。

试图将所有问题都减少到表格解决方案的倾向是一种巨大的反模式，遗憾的是，许多程序员从未学习过。不是一切都是一张桌子。那里也有树木和图表。

几乎所有解析作业都应该导致树的构造（可能是也可能不是复合模式的实现）。

Answer 2

生成操作树的一种方法的一个非常基本的例子。

我已经在一个Test类中嵌套了这些类（因为我不想用额外的文件来处理）但是它应该很简单，可以拆分）。

MathNode是表示树中节点的抽象类;
ElementNode是MathNode的子类，表示数字值（以及树的叶子）;
SumNode是表示操作的MathNode的子类;
tokenize()遍历字符串查找操作（或字符串的结尾）和前面的数字，并创建相应的标记并将它们附加到数组中。
makeTree()遍历标记数组，当找到当前正在搜索的操作时，将树的左右节点设置为前一个和后一个标记（一旦添加，就从数组中删除这些标记）到了树）。
运行tokenize()然后makeTree()四次，每次/，*，-和+操作一次，使用标记数组中剩下的单个节点构建树，树是树的根。

可以包含更多错误检查，并且我确信树构建可以显着提高效率（并且不需要四次通过），但是，希望这可以让您了解如何继续。< / p>

代码：

import java.util.ArrayList;

public class Test
{
    public static enum Operation { MULTIPLY, DIVIDE, ADD, SUBTRACT };
    abstract static class MathNode {
        public abstract double calc();
        public abstract String toString();
        public abstract boolean set( final MathNode left, final MathNode right, final Operation op );
    }
    static class ElementNode extends MathNode {
        private final double value;
        public ElementNode( final double v ) {
            this.value = v;
        }
        public double calc() {
            return value;
        }
        public String toString() {
            return Double.toString( value );
        }
        public boolean set( final MathNode left, final MathNode right, final Operation op ){
            return false;
        }
    }
    static class SumNode extends MathNode {
        public MathNode left = null;
        public MathNode right = null;
        public final Operation op;
        public SumNode( final Operation op ){
            this.op = op;
        }
        public boolean set( final MathNode left, final MathNode right, final Operation op ){
            if ( this.op == op )
            {
                this.left = left;
                this.right = right;
                return true;
            }
            return false;
        }
        public double calc() {
            final double l = left  == null ? 0 : left.calc();
            final double r = right == null ? 0 : right.calc();
            switch ( this.op ){
            case MULTIPLY:  return l * r;
            case DIVIDE:    return l / r;
            case SUBTRACT:  return l - r;
            default:        return l + r;
            }
        }
        public String toString(){
            final String l = left  == null?"0":left.toString();
            final String r = right == null?"0":right.toString();
            switch ( this.op ){
            case MULTIPLY:  return "( " + l + " * " + r + " )";
            case DIVIDE:    return "( " + l + " / " + r + " )";
            case SUBTRACT:  return "( " + l + " - " + r + " )";
            default:        return "( " + l + " + " + r + " )";
            }
        }
    }
    public static ArrayList<MathNode> tokenize( final String sum )
    {
        int i = 0,
            p = 0;
        final int l = sum.length();
        final ArrayList<MathNode> tokens = new ArrayList<MathNode>();
        while ( i < l )
        {
            final SumNode sn;
            switch ( sum.charAt(i) ){
            case '*':   sn = new SumNode( Operation.MULTIPLY ); break;
            case '/':   sn = new SumNode( Operation.DIVIDE );       break;
            case '+':   sn = new SumNode( Operation.ADD );      break;
            case '-':   sn = new SumNode( Operation.SUBTRACT ); break;
            default:
                // TODO: Add something to check if number is valid
                ++i; 
                continue;
            }
            // TODO: Add something to check for zero-width numbers 
            final double value = Double.parseDouble( sum.substring( p, i ) );
            p = ++i;
            tokens.add( new ElementNode( value ) );
            tokens.add( sn );
        }
        // TODO: Add something to check for zero-width numbers
        final double value = Double.parseDouble( sum.substring( p ) );
        tokens.add( new ElementNode( value ) );
        return tokens;
    }
    public static void makeTree( final ArrayList<MathNode> tokens, final Operation op ){
        for ( int i = tokens.size() - 2; i >= 1; --i )
        {
            final MathNode node = tokens.get( i );
            if ( node.set( tokens.get(i-1), tokens.get(i+1), op) )
            {
                tokens.remove( i + 1 );
                tokens.remove( i - 1 );
                --i;
            }
        }
    }
    public static void main(final String[] args) {
        final String sum = "23.2-5.2*4.4/2.2+14";
        final ArrayList<MathNode> tokens = tokenize( sum );
        makeTree( tokens, Operation.DIVIDE );
        makeTree( tokens, Operation.MULTIPLY );
        makeTree( tokens, Operation.SUBTRACT );
        makeTree( tokens, Operation.ADD );
        final MathNode sum_tree = tokens.get(0);
        System.out.println( sum_tree + " = " + sum_tree.calc() );
    }
}

Answer 3

您真的需要扫描所有操作员，计算优先级并重新排序所有内容吗？

如果您浏览了所有运算符和值，并仅评估*和/

，该怎么办？

然后重新浏览并评估+和-

可能比你想做的容易得多。

基于Java中的优先级重新排序数组

3 个答案: