二十四点--ccf（100分）

最新推荐文章于 2024-07-10 19:51:21 发布

原创最新推荐文章于 2024-07-10 19:51:21 发布 · 194 阅读

CC 4.0 BY-SA版权

本文介绍了一种基于逆波兰表达式的算法实现，通过使用两个栈（运算数栈和运算符栈）来解析并计算逆波兰表达式。该算法能够处理加、减、乘、除等基本运算，并通过具体代码示例详细展示了算法的工作流程。

import java.util.LinkedList;
import java.util.Scanner;

/**
 * @author 
 */
public class ReversePolish {
    /**
      存储运算数的栈
    **
    /
    private LinkedList<Integer> operandStack  = new LinkedList<>();
    /**
    存储运算符的栈
    **/
    private LinkedList<Character> operatorStack  = new LinkedList<>();
    private static final char END = '#';
    private void reversePolish(){
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        String compression;
        operatorStack.push(END);
        scanner.nextLine();
        for (int i = 0; i < n; i++) {
            int sum;
            compression = scanner.nextLine();
            for (int j = 0; j < compression.length(); j++) {
                switch (compression.charAt(j)){
                    case '+':if(operatorStack.getFirst() == END){
                        operatorStack.push('+');
                    }else{
                        sum = calculate(operatorStack.pop());
                        operatorStack.push('+');
                        operandStack.push(sum);
                    }break;
                    case '-':if(operatorStack.getFirst() == END){
                        operatorStack.push('-');
                    }else{
                        sum = calculate(operatorStack.pop());
                        operatorStack.push('-');
                        operandStack.push(sum);

                    }break;
                    case 'x':if(operatorStack.getFirst() == END || operatorStack.getFirst() == '+' || operatorStack.getFirst() == '-'){
                        operatorStack.push('x');
                    }else{
                        sum = calculate(operatorStack.pop());
                        operatorStack.push('x');
                        operandStack.push(sum);
                    }break;
                    case '/':if(operatorStack.getFirst() == END || operatorStack.getFirst() == '+' || operatorStack.getFirst() == '-'){
                        operatorStack.push('/');
                    }else{
                        sum = calculate(operatorStack.pop());
                        operatorStack.push('/');
                        operandStack.push(sum);
                    }break;
                    default:operandStack.push(Integer.parseInt(String.valueOf(compression.charAt(j))));
                }
            }
            while (operatorStack.getFirst() != END){
                sum = calculate(operatorStack.pop());
                operandStack.push(sum);
            }
            if(operandStack.pop() == 24){
                System.out.println("Yes");
            }else {
                System.out.println("No");
            }
        }
    }
    private int calculate(char operator){
        int op1 = operandStack.pop();
        int op2 = operandStack.pop();
        switch (operator){
            case '+':return op2 + op1;
            case '-':return op2 - op1;
            case 'x':return op2 * op1;
            // 除法
            default :return op2 / op1;
        }
    }

    public static void main(String[] args) {
        new ReversePolish().reversePolish();
    }
}

思路：其实就是一个正常算术表达式转换为逆波兰式的过程。需要一个运算数栈和一个运算符栈。对逆波兰式不熟悉的可以先看一下逆波兰式。