java中用split分割RPN表达式字符串之后如何识别数字和运算符

在Java中，可以使用正则表达式来识别数字和运算符。

对于数字，可以使用以下正则表达式：

String regex = "\\d+"; //匹配一个或多个数字

对于运算符，可以使用以下正则表达式：

String regex = "[+\\-*/]"; //匹配加减乘除四种运算符中的任意一个

使用split()方法将RPN表达式字符串分割成数字和运算符：

String[] tokens = rpnExpression.split("\\s+"); //将字符串按照空格分割成数组

for (String token : tokens) {
    if (token.matches("\\d+")) { //如果是数字
        //处理数字
    } else if (token.matches("[+\\-*/]")) { //如果是运算符
        //处理运算符
    } else {
        //处理其他情况
    }
}

在处理数字和运算符时，可以根据实际需求进行相应的处理。

相关问题

使用java输出一个表达式的逆波兰式串，计算他的值，参与的数字都是个位数

首先，需要了解逆波兰表达式的概念。逆波兰表达式，也叫后缀表达式，是一种不需要括号来标识优先级的数学表达式。它将运算符放在操作数的后面，因此也被称为后缀表示法。

例如，表达式（3+4）*5-6的逆波兰式为 3 4 + 5 * 6 -

计算逆波兰式的值可以使用栈来实现。具体步骤如下：

1. 从左到右扫描逆波兰式串
2. 遇到数字，将其压入栈中
3. 遇到运算符，弹出栈顶的两个数，进行相应的运算，并将结果压入栈中
4. 最终，栈中只剩下一个数，即为逆波兰式的计算结果

下面是一个实现以上步骤的java代码：

import java.util.*;

public class ReversePolishNotation {

    public static void main(String[] args) {
        String expression = "3+4*5-6";
        String rpn = toRPN(expression);
        System.out.println(rpn);
        int result = calculateRPN(rpn);
        System.out.println(result);
    }

    // 将中缀表达式转换为逆波兰式
    public static String toRPN(String expression) {
        StringBuilder rpn = new StringBuilder(); // 逆波兰式串
        Stack<Character> stack = new Stack<>(); // 运算符栈

        for (int i = 0; i < expression.length(); i++) {
            char ch = expression.charAt(i);
            if (Character.isDigit(ch)) { // 遇到数字，直接加入逆波兰式串
                rpn.append(ch);
            } else { // 遇到运算符
                while (!stack.isEmpty() && getPriority(stack.peek()) >= getPriority(ch)) {
                    // 如果栈顶运算符优先级大于等于当前运算符，弹出栈顶运算符加入逆波兰式串
                    rpn.append(stack.pop());
                }
                stack.push(ch); // 当前运算符入栈
            }
        }

        while (!stack.isEmpty()) { // 将剩余运算符弹出加入逆波兰式串
            rpn.append(stack.pop());
        }

        return rpn.toString();
    }

    // 计算逆波兰式的值
    public static int calculateRPN(String rpn) {
        Stack<Integer> stack = new Stack<>(); // 操作数栈

        for (int i = 0; i < rpn.length(); i++) {
            char ch = rpn.charAt(i);
            if (Character.isDigit(ch)) { // 遇到数字，入栈
                stack.push(ch - '0'); // 将字符转换为数字
            } else { // 遇到运算符，弹出栈顶的两个数，进行相应的运算，并将结果压入栈中
                int b = stack.pop();
                int a = stack.pop();
                switch (ch) {
                    case '+':
                        stack.push(a + b);
                        break;
                    case '-':
                        stack.push(a - b);
                        break;
                    case '*':
                        stack.push(a * b);
                        break;
                    case '/':
                        stack.push(a / b);
                        break;
                }
            }
        }

        return stack.pop(); // 栈中只剩下一个数，即为逆波兰式的计算结果
    }

    // 获取运算符的优先级
    public static int getPriority(char ch) {
        switch (ch) {
            case '+':
            case '-':
                return 1;
            case '*':
            case '/':
                return 2;
            default:
                return 0;
        }
    }
}

在上面的代码中，toRPN方法将中缀表达式转换为逆波兰式，calculateRPN方法计算逆波兰式的值，getPriority方法获取运算符的优先级。

对于输入的表达式"3+4*5-6"，运行以上代码的输出结果如下：

345*+6-
17

其中，逆波兰式串为"345*+6-"，计算结果为17。

js实现一个函数，对一个只包含数字，减号，加号，括号的字符串表达式求值，不能使用eval

为了实现对包含数字、减号、加号和括号的字符串表达式求值，可以使用逆波兰表达式（Reverse Polish Notation, RPN）算法来解决。具体步骤如下：

1. 创建两个栈，一个用于存储操作数 `operandStack`，一个用于存储运算符 `operatorStack`。

2. 将字符串表达式转换为逆波兰表达式。遍历字符串表达式，逐个字符进行处理。

3. 如果遇到数字字符，继续往后遍历，将连续的数字字符组成完整操作数，并将其添加到逆波兰表达式的末尾。

4. 如果遇到运算符字符，判断当前运算符与运算符栈顶元素的优先级。如果当前运算符优先级较高或与栈顶元素相等并且栈顶元素不是左括号，则将当前运算符压入运算符栈 `operatorStack`。

5. 如果遇到左括号字符，则直接将其压入运算符栈 `operatorStack`。

6. 如果遇到右括号字符，则从运算符栈 `operatorStack` 弹出运算符并添加到逆波兰表达式的末尾，直到遇到左括号为止。

7. 遍历完整个表达式后，如果运算符栈 `operatorStack` 不为空，则依次弹出运算符并添加到逆波兰表达式的末尾。

8. 通过逆波兰表达式计算结果。遍历逆波兰表达式，逐个元素进行处理。

9. 如果遇到操作数，则将其压入操作数栈 `operandStack`。

10. 如果遇到运算符，则从操作数栈 `operandStack` 弹出两个操作数进行计算，并将结果压入操作数栈 `operandStack`。

11. 最后，操作数栈 `operandStack` 中的唯一元素即为表达式的求值结果。

下面是实现上述逻辑的 JavaScript 函数：

function evaluateExpression(expression) {
  // 运算符优先级映射
  const precedence = {
    '+': 1,
    '-': 1,
    '(': 0
  };

  // 将中缀表达式转换为逆波兰表达式
  function convertToRPN(infixExpression) {
    const rpn = []; // 逆波兰表达式
    const operatorStack = []; // 运算符栈

    for (let i = 0; i < infixExpression.length; i++) {
      const char = infixExpression[i];

      if (/\d/.test(char)) { // 数字字符
        let numStr = char;

        // 继续往后遍历，将连续的数字字符组成完整的操作数
        while (/\d/.test(infixExpression[i + 1])) {
          numStr += infixExpression[i + 1];
          i++;
        }

        rpn.push(Number(numStr));
      } else if (char === '+' || char === '-') { // 运算符字符
        while (
          operatorStack.length > 0 &&
          precedence[char] <= precedence[operatorStack[operatorStack.length - 1]]
        ) {
          rpn.push(operatorStack.pop());
        }

        operatorStack.push(char);
      } else if (char === '(') { // 左括号字符
        operatorStack.push(char);
      } else if (char === ')') { // 右括号字符
        while (operatorStack[operatorStack.length - 1] !== '(') {
          rpn.push(operatorStack.pop());
        }

        operatorStack.pop(); // 弹出左括号
      }
    }

    while (operatorStack.length > 0) { // 处理剩余运算符
      rpn.push(operatorStack.pop());
    }

    return rpn;
  }

  // 使用逆波兰表达式计算结果
  function calculateRPN(rpnExpression) {
    const operandStack = []; // 操作数栈

    for (let i = 0; i < rpnExpression.length; i++) {
      const token = rpnExpression[i];

      if (typeof token === 'number') { // 操作数
        operandStack.push(token);
      } else { // 运算符
        const operand2 = operandStack.pop();
        const operand1 = operandStack.pop();

        switch (token) {
          case '+':
            operandStack.push(operand1 + operand2);
            break;
          case '-':
            operandStack.push(operand1 - operand2);
            break;
        }
      }
    }

    return operandStack[0];
  }

  const rpnExpression = convertToRPN(expression);
  return calculateRPN(rpnExpression);
}

使用示例：

console.log(evaluateExpression("2+3*(4-1)")); // 输出 11
console.log(evaluateExpression("5+(6-2)*8")); // 输出 37
console.log(evaluateExpression("(1+2)*(3-4)+5")); // 输出 2

这样，我们就可以通过将字符串表达式转换为逆波兰表达式，并使用逆波兰表达式来计算结果，实现对包含数字、减号、加号和括号的字符串表达式求值，而不使用 `eval` 函数。