在Java中，如何在所有数字之后移动所有运算符？

在infix.txt中给出的所有数字之后，如何将所有运算符移动到

"1.5 - 3.16 * 2.333 / 0.25 + 4.1"

输出应为：

0.25 1.5 2.333 3.16 4.1 + - * /

这是密码

public class SplitString{
   static boolean isOperator(char ch){
     return ch=='+' || ch=='-' || ch=='/' || ch=='*';
   }

   static boolean precedence(char a,char b){
     switch(a){
         case '+': return !(b=='-') || !(b=='*') || (b=='+') || !(b=='/');
        default : return false;
     }
   }

  static public void main(String... args){
       String filename="infix.txt";
       StringBuffer sb=new StringBuffer();
       try{
             java.util.Scanner sc=new java.util.Scanner(new java.io.File(filename));
             while(sc.hasNextLine()){
                   String s=sc.nextLine();
                   System.out.println(s);
                   java.util.Stack stack=new java.util.Stack();
                   String[] st=s.split("\\s");
                   for(String ss:st){
                         char ch=ss.charAt(0);
                         if(isOperator(ch)){
                               switch(ch){
                                     case '+': if (!stack.empty() || stack.peek().toString().charAt(0)=='+')
                                           stack.pop();
                                           else stack.push(ch);
                                           break;
                                     case '-': if (!stack.empty() || stack.peek().toString().charAt(0)=='-')
                                           stack.pop();
                                           else stack.push(ch);
                                           break;
                                     case '*': if (!stack.empty() || stack.peek().toString().charAt(0)=='*')
                                           stack.pop();
                                           else stack.push(ch);
                                           break;
                                     case '/': if (!stack.empty() || stack.peek().toString().charAt(0)=='/')
                                           stack.pop();
                                           else stack.push(ch);
                                           break;        
                               }
                         }else sb.append(ss);
                   }
                     for(;!stack.empty();sb.append(stack.pop()));
                     System.out.println(sb.toString());
             }
       }catch(Exception e){ e.getMessage();}                    
  }
}

---

所以死亡之吻是这样的：

 }catch(Exception e){ e.getMessage();}         

在这里，如果您得到一个异常，则不打印该异常。这很少是个好主意。当我运行这个时，它给了我一个警告。这是因为你有如果！stack.empty | | stack.peek.toString.charAt0==。。。当你有| |时，两边都会被评估。因此，在第一次运行时，堆栈将为空，调用Stack.peek将引发异常。我相信你想把所有的| |改成&。这样，如果堆栈为空，则不会计算右侧。当你改变它时，它将产生：测试用例8*9+9

接下来，我们需要弄清楚如何使用优先级方法。我编写了一个order方法，它简单地迭代堆栈，检查优先级更高的堆栈，并相应地重新排序堆栈。通过这些更改，我们得到：

899*+

几点注意：

如果文本文件包含空行，这将导致错误 将堆栈更改java.util.Stack Stack=new java.util.Stack参数化是一种很好的做法；to java.util.Stack Stack=new java.util.Stack； 正如上面提到的，吃一个例外几乎从来都不是一个好主意。将catchException e{e.getMessage；}更改为catchException e{e.printStackTrace；} 以下是更改后的代码：

static boolean isOperator(char ch){
     return ch=='+' || ch=='-' || ch=='/' || ch=='*';
   }

   static boolean precedence(Character a,Character b){
     switch(a){
         case '+': return !(b=='-') || !(b=='*') || (b=='+') || !(b=='/');
        default : return false;
     }
   }

  static public void main(String... args){
       String filename="king.txt";
       StringBuffer sb=new StringBuffer();
       try{
             java.util.Scanner sc=new java.util.Scanner(new java.io.File(filename));
             while(sc.hasNextLine()){
                   String s=sc.nextLine();
                   System.out.println(s);
                   java.util.Stack<Character> stack=new java.util.Stack<Character>();
                   String[] st=s.split("\\s");
                   for(String ss:st){
                         char ch=ss.charAt(0);
                         if(isOperator(ch)){
                               switch(ch){
                                     case '+': if (!stack.empty() && stack.peek().toString().charAt(0)=='+')
                                           stack.pop();
                                           else stack.push(ch);
                                           break;
                                     case '-': if (!stack.empty() && stack.peek().toString().charAt(0)=='-')
                                           stack.pop();
                                           else stack.push(ch);
                                           break;
                                     case '*': if (!stack.empty() && stack.peek().toString().charAt(0)=='*')
                                           stack.pop();
                                           else stack.push(ch);
                                           break;
                                     case '/': if (!stack.empty() && stack.peek().toString().charAt(0)=='/')
                                           stack.pop();
                                           else stack.push(ch);
                                           break;        
                               }
                         }else sb.append(ss);
                   }
                   order(stack);
                     for(;!stack.empty();sb.append(stack.pop()));
                        System.out.println(sb.toString());


             }
       }catch(Exception e){ e.printStackTrace();}        

  }
  static Stack<Character> order(Stack<Character> stack) {
      for(int i = 0; i < stack.size()-1; i++) {
          if(!precedence(stack.elementAt(i), stack.elementAt(i+1))) {
              Character temp = stack.pop();
              Character temp2 = stack.pop();
              stack.push(temp);
              stack.push(temp2);

          }
      }
      return stack;
  }

---

这里有一种不使用堆栈的方法，只使用数组和排序算法

把数字分开 分拆操作员 对数字进行排序 对操作符进行排序 将已排序的数字与已排序的运算符组合 密码

---

负数呢？你想把负数也移一下吗？@YCF_L根据我教授的说法，现在就忽略负数，这样我们就不会混淆了。好的，你的代码有什么问题吗？@YCF_L现在只显示中缀文件中的内容。它不会将所有运算符移到左侧。*的优先级高于+。请参阅维基百科。我应该包含什么库，它给出了错误。堆栈错误：在导入java.util.Stack；？时找不到SYMBOLID；？哇，它成功了，你说的是正确的，把| |改成&。非常感谢您，先生，我如何添加空间或使用空格或逗号拆分它们？@MicFlurry，您可以在其中添加+它非常有效，但如果我使用它，我添加一些代码/条件的努力将毫无意义。但是我真的很感谢你的帮助，我试着学习了你的代码，关于如何用空格和逗号分割数字和运算符，仍然很困惑，lol。分割是使用正则表达式模式完成的。Arrays.toString将逗号添加到输出中。我应该如何使用我的代码？现在可以正常工作，但输出没有空格。

static boolean isOperator(char ch){
     return ch=='+' || ch=='-' || ch=='/' || ch=='*';
   }

   static boolean precedence(Character a,Character b){
     switch(a){
         case '+': return !(b=='-') || !(b=='*') || (b=='+') || !(b=='/');
        default : return false;
     }
   }

  static public void main(String... args){
       String filename="king.txt";
       StringBuffer sb=new StringBuffer();
       try{
             java.util.Scanner sc=new java.util.Scanner(new java.io.File(filename));
             while(sc.hasNextLine()){
                   String s=sc.nextLine();
                   System.out.println(s);
                   java.util.Stack<Character> stack=new java.util.Stack<Character>();
                   String[] st=s.split("\\s");
                   for(String ss:st){
                         char ch=ss.charAt(0);
                         if(isOperator(ch)){
                               switch(ch){
                                     case '+': if (!stack.empty() && stack.peek().toString().charAt(0)=='+')
                                           stack.pop();
                                           else stack.push(ch);
                                           break;
                                     case '-': if (!stack.empty() && stack.peek().toString().charAt(0)=='-')
                                           stack.pop();
                                           else stack.push(ch);
                                           break;
                                     case '*': if (!stack.empty() && stack.peek().toString().charAt(0)=='*')
                                           stack.pop();
                                           else stack.push(ch);
                                           break;
                                     case '/': if (!stack.empty() && stack.peek().toString().charAt(0)=='/')
                                           stack.pop();
                                           else stack.push(ch);
                                           break;        
                               }
                         }else sb.append(ss);
                   }
                   order(stack);
                     for(;!stack.empty();sb.append(stack.pop()));
                        System.out.println(sb.toString());


             }
       }catch(Exception e){ e.printStackTrace();}        

  }
  static Stack<Character> order(Stack<Character> stack) {
      for(int i = 0; i < stack.size()-1; i++) {
          if(!precedence(stack.elementAt(i), stack.elementAt(i+1))) {
              Character temp = stack.pop();
              Character temp2 = stack.pop();
              stack.push(temp);
              stack.push(temp2);

          }
      }
      return stack;
  }

import java.util.Arrays;

public class MyClass {
    public static void main(String args[]) {
        String data = "1.5 - 3.16 * 2.333 / 0.25 + 4.1";
        // Remove any spaces
        data = data.replaceAll("\\s+", "");
        System.out.println(data);

        // Get the numbers
        String[] numbers = data.split("[+*/-]");
        System.out.println(Arrays.toString(numbers));

        // Get the operators
        String[] operators = data.replaceAll("\\d*[.]?\\d*", " ").trim().split("  "); // Operators are separated by 2 spaces
        System.out.println(Arrays.toString(operators));

        // Sort the numbers (Simple bubble sort)
        String temp = "";
        for (int i = 0; i < numbers.length; i++) {
            double num1 = Double.valueOf(numbers[i]);
            for (int j = 1; j < (numbers.length - i); j++) {
                double num2 = Double.valueOf(numbers[j]);
                if (num1 > num2) {
                    temp = numbers[i];
                    numbers[i] = numbers[j];
                    numbers[j] = temp;
                }
            }
        }

        System.out.println(Arrays.toString(numbers));

        // Sort operators (+, -, *, /)
        int index = 0;
        index = moveOperator(operators, "+", index);
        index = moveOperator(operators, "-", index);
        index = moveOperator(operators, "*", index);
        index = moveOperator(operators, "/", index);
        System.out.println(Arrays.toString(operators));

        // Combine arrays
        String[] answer = Arrays.copyOf(numbers, numbers.length + operators.length);
        System.arraycopy(operators, 0, answer, numbers.length, operators.length);
        System.out.println(Arrays.toString(answer));
    }

    private static int moveOperator(String[] operators, String operator, int index) {
        String temp = "";
        for (int i = index + 1; i < operators.length; i++) {
            if (operators[i].contentEquals(operator)) {
                temp = operators[index];
                operators[index] = operators[i];
                operators[i] = temp;

                index++;
            }
        }

        return index;
    }
}

1.5-3.16*2.333/0.25+4.1
[1.5, 3.16, 2.333, 0.25, 4.1]
[-, *, /, +]
[0.25, 3.16, 1.5, 2.333, 4.1]
[+, -, *, /]
[0.25, 3.16, 1.5, 2.333, 4.1, +, -, *, /]