使用2个通用堆栈验证表达式

Question

任务是实现一个通用堆栈（不能使用java中的库），使用true和false为布尔b1和b2输入表达式，逻辑运算符（and，or，not，iff，implies）识别其布尔or运算符并发送到2个堆栈，然后弹出堆栈以评估其是否为有效表达式，即：输入：（b1和b2）意味着b3是一个有效的表达式，但b3和（b2 or）不是，我对堆栈部分有问题，因为peek没有返回任何元素，这是我到目前为止的代码，注意：字符是因为我要检查括号是否平衡：

public class MyStack<T> {

    class StackOverFlowException extends RuntimeException{}
    class EmptyStackException extends RuntimeException{}
    
    private T[] stack;
    private int top;
    
    public MyStack(int size) {
        this.stack = (T[]) new Object[size];
        this.top = 0;   
        
    }
    
    public boolean isEmpty() {
        return this.top == 0;
    }
    
    public boolean isFull() {
        return this.top == stack.length;
    }
    
    public void push(T x) {
        if(top == stack.length) {
            throw new StackOverFlowException();
        }
        else {
            this.stack[top] = x;
            top++;
        }
    }
    
    public T pop() {
        if(isEmpty()) {
            throw new EmptyStackException();
        }
        else {
            T value = this.stack[--top];
            return value;
        }
    }
    
    public T peek() {
        return this.stack[top];
    }
    
    public static void main(String[] args) {
        MyStack<String> tf = new MyStack(100);
        MyStack<String> operators = new MyStack(100);
        
        System.out.println("Please input the expression to evaluate: ");
        Scanner scn = new Scanner(System.in);   
        String expression = scn.nextLine();
        String tokens[] = expression.split(" ");
        int n = tokens.length;
        boolean P1 = true;
        boolean P2 = true;
        boolean result = true;
        
        for(int i = 0; i < n; i++ ) {
        
            String separate = tokens[i];
            char x = separate.charAt(i);
            if(tokens[i].equalsIgnoreCase("true")||tokens[i].equalsIgnoreCase("false")) {
                tf.push(separate);
                tf.peek();

            }
            else if(tokens[i].equalsIgnoreCase("and")||tokens[i].equalsIgnoreCase("not")||tokens[i].equalsIgnoreCase("or")||tokens[i].equalsIgnoreCase("implies")||tokens[i].equalsIgnoreCase("iff")) {
                operators.push(separate);
            }
            
            else {
                System.out.println("Expression not Valid!");
            }
            
        }
        
        
        
        
        
        
    
    }

Answer 1

在peek（）方法（以及isEmpty（）方法）中，top变量被误解。

在实现时，top是一个误称，因为它实际上是堆栈的大小（也可能被视为下一个要推送的元素的索引）。因此，您的peek（）方法应该查看顶部之前的元素。

或者，您可以将顶部定义为堆栈顶部的元素，因为这通常是您在其他地方使用它的方式。在这种情况下，您需要定义一个标志值来指示堆栈为空。

在任何情况下，都需要在方法中处理空堆栈的情况。

public class MyStack {
  private static final int EMPTY = -1;
  private int top = EMPTY;

  ... other stuff ...

  public boolean isEmpty() {
    return EMPTY == top;
  }
  public T peek() {
    if (ifEmpty()) {
       throw new EmptyStackException("Cannot peek into empty Stack");
    }
    return stack[top];
  }
}