Question

当输入运算符为（+， - ，*，/）时，如何评估使用堆栈计算两个操作数？例如输入：
3
4
5
+
输出：
4 + 5 = 9
输入：
*
输出：
3 * 9 = 27
输入：
10个
/
输出：
27/10 = 2.7
输入：
1
-
输出：2.7-1 = 1.7
我的问题是我无法将输入存储为整数，然后对其进行评估以产生这样的输出我的Stack（）代码

public class Stack {

    int maxSize;
    int top;
    String array[];

    public Stack(int n)
    {
        maxSize = n;
        array = new String[maxSize];
        top = 0;
    }

    public boolean empty()
    {
        if(top==0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public void push(String str)
    {
        if(top < maxSize)
        {
        array[top] = str;
        top++;
        }
        else
        {
            System.out.println("Stack Overflow !!!");
        }
    }

    public String pop()
    {
        if(!this.empty())
        {
            String temp = this.peek();
            array[top-1] = null;
            top--;
            return temp;
        }
        else
        {
            return null;
        }
    }

    public String peek()
    {
        if(top > 0) 
        {
        return array[top-1];
        }
        else
        {
            return null;
        }
    }

}

我的主要代码

public static void main(String[] args) {
        // Stack<Integer> stack = new Stack<Integer>();  <-- error?
        Scanner sc = new Scanner(System.in);
        Stack myStak = new Stack(3);
        System.out.println("Input : ");


        String input;
    do{
       input = sc.next()+sc.nextLine();
       myStak.push((input));
       String operator = myStak.peek();
        switch(operator.charAt(0))
        {
            case '+':
            int a = Integer.parseInt(myStak.pop());
            int b = Integer.parseInt(myStak.pop());
            int result = a+b;
            myStak.push(Integer.toString(result));
            System.out.print("Output : ");
            System.out.print(a+" + "+b+" = "+result);
                break;
        }
           // myStak.push(myStak.pop() + myStak.pop());
           // System.out.println("Output:");
           // System.out.println(myStak.pop()+"+"+myStak.pop());


    }
    while(input!= "+" || input!= "-" || input!= "*" || input!= "/");

Answer 1

您的代码中存在多个小错误。您应该学习使用调试器并注意警告 - Netbeans立即给出了一个......

input = sc.next()+sc.nextLine();并非真正的错误，但是我无法理解为什么这个结构：你得到一个单一的标记，并立即将它与行尾连接得到直接nextLine给出的 - 为什么不仅仅是input = sc.next();？
堆栈上不需要的运算符：
```
   myStak.push((input));
   String operator = myStak.peek();
    switch(operator.charAt(0))
    {
        case '+':
        int a = Integer.parseInt(myStak.pop());
```
执行Integer.parseInt(myStak.pop())时，最后一个令牌是......可能抛出ParseException的运算符！要么首先弹出操作员，要么最好不要推动操作员......
其他运营商仍未实施......
从不使用==来比较字符串或对象，但仅使用equals。这一行：
```
while(input!= "+" || input!= "-" || input!= "*" || input!= "/");
```
应该（更简单和正确）：
```
while (! "+-*/".contains(input));
```
Netbeans立即检测到这一点，我认为任何IDE或Java编译器都应该发出警告。

最后一句话，因为你只使用整数，27/10将是2而不是2.7

以下是代码的清理版本：

public static void main(String[] args) {
    // Stack<Integer> stack = new Stack<Integer>();  <-- error?
    Scanner sc = new Scanner(System.in);
    Stack myStak = new Stack(16);   // I broke at 3 at first test...
    System.out.println("Input : ");

    String input;
    while (true) {
        input = sc.next();    // let the Scanner deal with spaces and newlines
        String operator = input.substring(0, 1);
        if ("+-/*".contains(operator)) {  // is it an operator?
            int a = Integer.decode(myStak.pop()); // yes unpack and compute
            int b = Integer.decode(myStak.pop());
            int result = compute(a, b, operator);
            myStak.push(String.valueOf(result)); // push result back to stack and display
            System.out.println(a + " " + operator + " " + b + " = " + result);
        } else if ("=".equals(operator)) { // stop on =
            break;
        } else {
            myStak.push(input); // not an operator: assume a number and push it
        }
    }
}

// one single static function to avoid code duplication (DRY principle)
private static int compute(int i, int j, String op) {
    switch (op.charAt(0)) {
        case '+':
            return i + j;
        case '-':
            return i - j;
        case '*':
            return i * j;
        case '/':
            return i / j;
    }
    return 0;
}

Stack Postfix评估？

1 个答案: