Java 通过堆栈使用完整的公式括号计算代数公式

我试图通过堆栈计算带有完整公式括号的代数公式。 例如，我有一个公式：（（6∗ (4+2))+(5−1)). 右大括号表示堆栈应停止“读取”并使用大括号集计算术语。 我的堆栈应该“读取”到第一个右大括号，然后计算（4+2）内的forumula，然后它会注意到第二个右大括号并计算它。在我的例子中，它将是6*6（正如4+2）之前计算的那样。 接下来的5-1需要读入堆栈并进行计算，最后的4将添加到36

堆栈的实现方式如下所示：

public class Stack<T> {
private List<T> elemente = new ArrayList<T>();

   public void push(T element) {
        elemente.add(element);
    }


    public T pop() {
        if (elemente.size() == 0) {
            throw new IllegalArgumentException("Stack ist leer.");
        }
        T element = elemente.get(elemente.size() - 1);
        elemente.remove(elemente.size() - 1);
        return element;
    }


    public T top() {
        if (elemente.size() == 0) {
            throw new IllegalArgumentException("Stack ist leer.");
        }
        return elemente.get(elemente.size() - 1);
    }

    public T showElems(int i) {
            return this.elemente.get(i);
    }

    public int showSize() {
        return this.elemente.size();
    }

    public boolean isEmpty() {
        return elemente.size() == 0;
    }
    public void clear() {
        elemente.clear();
    }}

public class Parser {


static Stack<String> stack = new Stack<String>();
static String ausdruck = "( ( 2 * ( 6 *  ( 4 + 2 ) )  ) + ( 6 *  ( 4 + 2 ) ) * ( 8 / 2 )   )  ";
static Scanner s = new Scanner(ausdruck);

public static void main(String[] args) {

    Parser.routine();
    Parser.showErg();
}

public static void berechne() {

    while (!stack.isEmpty() && stack.showSize() > 3) {

        Integer operator1 = Integer.parseInt(stack.pop());
        String operation = stack.pop();
        Integer operator2 = Integer.parseInt(stack.pop());
        stack.pop();

        System.out.println("");
        System.out.println(operator1);
        System.out.println(operation);
        System.out.println(operator2);
        System.out.println("");

        if (operation.equals("+")) {
            stack.push(Integer.toString(operator1 + operator2));
        }
        if (operation.equals("-")) {
            stack.push(Integer.toString(operator2 - operator1));
        }
        if (operation.equals("*")) {
            stack.push(Integer.toString(operator1 * operator2));
        }
        if (operation.equals("/")) {
            stack.push(Integer.toString(operator2 / operator1));
        }

    }
}

public static void printStack() {
    for (int i = 0; i < stack.showSize(); i++) {
        System.out.println(stack.showElems(i) + " --- StackPos ---> " + i);

    }
    System.out.println("");
}

public static void routine() {
    stack.push("ende");

    while (s.hasNext()) {

        String temp = s.next();

        switch (temp) {
        case ")":
            Parser.printStack();
            Parser.berechne();
            break;
        default:
            stack.push(temp);
            break;
        }
    }

    s.close();
}


public static void showErg() {

    String erg = stack.pop();

    System.out.println("Ergebnis : " + erg);
}

公共类堆栈{
private List element=new ArrayList（）；
公共无效推送（T元素）{
元素e.添加（元素）；
}
公共广播电台{
if（elemente.size（）=0）{
抛出新的IllegalArgumentException（“Stack ist leer”）；
}
T element=elemente.get（elemente.size（）-1）；
elemente.remove（elemente.size（）-1）；
返回元素；
}
公共T top（）{
if（elemente.size（）=0）{
抛出新的IllegalArgumentException（“Stack ist leer”）；
}
返回elemente.get（elemente.size（）-1）；
}
公共T-showElems（国际一级）{
返回此.elemente.get（i）；
}
公共int showSize（）{
返回此.elemente.size（）；
}
公共布尔值为空（）{
返回elemente.size（）==0；
}
公共空间清除（）{
元素e.clear（）；
}}

我提出了以下建议：

public class Stack<T> {
private List<T> elemente = new ArrayList<T>();

   public void push(T element) {
        elemente.add(element);
    }


    public T pop() {
        if (elemente.size() == 0) {
            throw new IllegalArgumentException("Stack ist leer.");
        }
        T element = elemente.get(elemente.size() - 1);
        elemente.remove(elemente.size() - 1);
        return element;
    }


    public T top() {
        if (elemente.size() == 0) {
            throw new IllegalArgumentException("Stack ist leer.");
        }
        return elemente.get(elemente.size() - 1);
    }

    public T showElems(int i) {
            return this.elemente.get(i);
    }

    public int showSize() {
        return this.elemente.size();
    }

    public boolean isEmpty() {
        return elemente.size() == 0;
    }
    public void clear() {
        elemente.clear();
    }}

public class Parser {


static Stack<String> stack = new Stack<String>();
static String ausdruck = "( ( 2 * ( 6 *  ( 4 + 2 ) )  ) + ( 6 *  ( 4 + 2 ) ) * ( 8 / 2 )   )  ";
static Scanner s = new Scanner(ausdruck);

public static void main(String[] args) {

    Parser.routine();
    Parser.showErg();
}

public static void berechne() {

    while (!stack.isEmpty() && stack.showSize() > 3) {

        Integer operator1 = Integer.parseInt(stack.pop());
        String operation = stack.pop();
        Integer operator2 = Integer.parseInt(stack.pop());
        stack.pop();

        System.out.println("");
        System.out.println(operator1);
        System.out.println(operation);
        System.out.println(operator2);
        System.out.println("");

        if (operation.equals("+")) {
            stack.push(Integer.toString(operator1 + operator2));
        }
        if (operation.equals("-")) {
            stack.push(Integer.toString(operator2 - operator1));
        }
        if (operation.equals("*")) {
            stack.push(Integer.toString(operator1 * operator2));
        }
        if (operation.equals("/")) {
            stack.push(Integer.toString(operator2 / operator1));
        }

    }
}

public static void printStack() {
    for (int i = 0; i < stack.showSize(); i++) {
        System.out.println(stack.showElems(i) + " --- StackPos ---> " + i);

    }
    System.out.println("");
}

public static void routine() {
    stack.push("ende");

    while (s.hasNext()) {

        String temp = s.next();

        switch (temp) {
        case ")":
            Parser.printStack();
            Parser.berechne();
            break;
        default:
            stack.push(temp);
            break;
        }
    }

    s.close();
}


public static void showErg() {

    String erg = stack.pop();

    System.out.println("Ergebnis : " + erg);
}

公共类解析器{
静态堆栈=新堆栈（）；
静态字符串ausdruck=“（2*（6*（4+2）））+（6*（4+2））*（8/2））”；
静态扫描仪s=新扫描仪（Austruck）；
公共静态void main（字符串[]args）{
Parser.routine（）；
sparser.g（）；
}
公共静态无效berechne（）{
而（！stack.isEmpty（）&&stack.showSize（）>3）{
整数运算符1=Integer.parseInt（stack.pop（））；
字符串操作=stack.pop（）；
整数运算符2=Integer.parseInt（stack.pop（））；
stack.pop（）；
System.out.println（“”）；
系统输出打印项次（操作员1）；
系统输出打印项次（操作）；
系统输出打印项次（操作员2）；
System.out.println（“”）；
if（操作.等于（“+”））{
stack.push（Integer.toString（运算符1+运算符2））；
}
if（运算.等于（“-”）{
stack.push（Integer.toString（运算符2-运算符1））；
}
if（操作。等于（“*”）{
stack.push（Integer.toString（运算符1*运算符2））；
}
if（操作.等于（“/”）{
stack.push（Integer.toString（运算符2/运算符1））；
}
}
}
公共静态void printStack（）{
对于（int i=0；i”+i）；
}
System.out.println（“”）；
}
公共静态无效例程（）{
堆叠推送（“ende”）；
而（s.hasNext（））{
字符串temp=s.next（）；
开关（温度）{
案例“）”：
printStack（）；
Parser.berechne（）；
打破
违约：
堆栈推送（温度）；
打破
}
}
s、 close（）；
}
公共静态真空淋浴器（）{
字符串erg=stack.pop（）；
System.out.println（“Ergebnis:+erg”）；
}

}

我的问题是，如果我添加另一个大括号深度，我的解析器将无法正常工作。如果我尝试下面的方法，而不是上面的forluma，则会出现数字格式异常。 不起作用的示例：（（6）∗ (4+2))+(5−1） ）*3）

---

谢谢大家!

好的，一般来说，最好用英语编写代码，因为这样可以更清楚地了解代码的功能。 其次，您使用的不是堆栈，而是后进先出队列，而堆栈是先进先出队列。这也相当令人困惑。 来回答你的问题。 在代码中匹配一个-即unicode符号45， 在您使用的输入中−, 哪个u是稍长的负号？这是unicode符号8722。

---

另外，请修改您的代码以使用字符而不是字符串，因为现在您必须在所有位置添加空格：）

您的代码甚至不能使用代码中的公式，因为它会在遇到

）

时计算所有堆叠的操作。每个

）

只能执行一次计算。