如何将反向波兰符号转换为常规符号？

据我了解，作者要求一种算法。我会这样写：
1. 我们将字符串按空格敲入数组中。
2. 我们使用以下规则遍历数组
：如果有数字，我们将其放入堆栈。
湾。如果操作被捕获，那么我们从堆栈中获取所需数量的操作数。对于一元1，对于二元2。在二元运算的情况下，很明显顶部元素是第二个操作数。我们将结果放入堆栈。
3. 在输出处，我们有一个包含一个元素的堆栈。
它将如何在示例中工作：
取第一个元素 (2) - 这是一个数字 - 将其放入堆栈 - 当前堆栈：2
第二个元素 (3) - 这是一个数字 - 将其放入堆栈 - 当前堆栈：3,2
第三个元素（+）是二元运算——我们得到3，然后是2，放回2+3——当前栈：2+3
接下来，我会给出栈的状态：
（6）6,2+3
（ 2) 2,6,2+ 3
(/) 6/2.2+3
(5) 5.6/2.2+3
(2) 2.5.6/2.2+3
(*) 5*2.6/2.2+ 3
(-) 6/ 2 -5*2.2+3
(+) 2+3 + 6/2 - 5*2

String input="2 3 + 6 2 / 5 2 * - +";
Stack stack=new Stack();
for(String element:input.split[' ']){
if(*проверка является ли элемент числом*){
   stack.push(element);
}else if(*проверка является ли операция унарной*){
   String op1=stack.pop();
   stack.push(op1+element);
}else{
   String op2=stack.pop();
   String op1=stack.pop();
   stack.push(op1+element+op2);
}
}
String result=stack.pop()

这是正确的答案：
括号是必不可少的。
试试这个： 2 3 + 6 2 / 5 2 + -
((2+3) ((6/2)-(5+2))) == -20
这里你可以检查第7 个 Download（可以解决两种类型的表达式）。

fromRPN( new ArrayList<String>( Arrays.asList( "2 3 + 6 2 / 5 2 + - *".split( " " ) ) ) ); // ((2+3)*((6/2)-(5+2)))

public String fromRPN( ArrayList<String> rpn ) {
  for( int n = 0; rpn.size() > 1; n++ )
    switch( rpn.get( n ) ) {
    case "+":
    case "-":
    case "*":
    case "/":
      String s = new StringJoiner( "", "(", ")" ).add( rpn.remove( n - 2 ) ).add( rpn.remove( n - 1 ) ).add( rpn.remove( n - 2 ) ).toString();
      rpn.add( n - 2, s );
      if( rpn.size() > 1 )
        return( fromRPN( rpn ) );
      return( rpn.get( 0 ) );
    case "sqrt":  // insert Your unary operator(s) here…
      StringJoiner join = rpn.get( n ).startsWith( "(" ) ? new StringJoiner( "" ) : new StringJoiner( "",  "(", ")" );
      join.add( rpn.remove( n ) );
      if( rpn.get( n - 1  ).startsWith( "(" ) )
        join.add( rpn.remove( n - 1 ) );
      else
        join.add( "(" ).add( rpn.remove( n - 1 ) ).add( ")" );
      s = join.toString();
      rpn.add( n - 1, s );
      if( rpn.size() > 1 )
        return( fromRPN( rpn ) );
      return( rpn.get( 0 ) );
    }
  return( fromRPN( rpn ) );
}

逻辑是这样的，只有在这里问题是针对特定示例正面解决的，对于更广泛的解决方案，您需要检查，即 按空格对字符串的字符进行排序，我的解决方案仅适用于成对的数字，如果有单独的数字将不起作用，但仅此而已

 import com.sun.deploy.util.StringUtils;

import java.util.*;

public class hj{
    public static void main(String[] args) {
        String value = "2 3 + 6 2 / 5 2 * - +";
        String[] substring = value.split(" ");
        ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(substring));
        ArrayList<String> list = new ArrayList<String>();
        ArrayList<String>temp = new ArrayList<String>();
        int size = arrayList.size();
        for (int i = 0; i < arrayList.size(); i++) {
            if (i>0 &&i % 3 == 0)
                   list.add(0,arrayList.get(i-3)+arrayList.get(i-1)+arrayList.get(i-2));

        }
        int size1 = arrayList.size()-list.size()+1;
        size=arrayList.size()-size1;
        Collections.reverse(arrayList);
        for (int i = 0; i < arrayList.size()-size1; i++) {
            temp.add(arrayList.get(i));
        }
        Collections.reverse(temp);
        for (int i = 0; i < temp.size(); i++) {
            list.add(1+i*2,temp.get(i));
        }
        Collections.reverse(list);

        System.out.println(list.toString());
    }
}