反向波兰符号C#don'；我不能正常工作

我写了一个带有结构图的rpn

最新问题：现在无法正常工作

如果输入字符串为“5+（（1+2）*4）-3”

我的输出是： 512+4*3-+

我必须得到这个结果： 512+4*+3-

编辑了源文件

*这是最初的问题，但帮助了我，现在原来的错误得到了纠正：

在调试时，当循环或 int i=12，c值为0\0或其他值 这个值作为一个“（”括号添加到输出（名称：公式）字符串中。我不知道为什么。 和最后一个“-”操作符号，不添加到输出字符串末尾的（或不查看）（公式） 我错估了这个问题是由“（”引起的。 我尝试了使用其他字符串输入值的程序，但总是在我的字符串中添加一个“（”，我不知道为什么…我发现它与括号的数量无关。始终只有一个“（”添加到我的字符串…*） 是的，英语LengyelFormula=rpn（它是匈牙利语）*

static void Main（字符串[]args）
{
字符串str=“5+（（1+2）*4）−3";
字符串结果=LengyelFormaKonvertalas（str）；
Console.WriteLine（result.ToString（））；
Console.ReadLine（）；
}
静态字符串LengyelFormaKonvertalas（字符串输入）//这是rpn方法
{
堆栈=新堆栈（）；
String str=input.Replace（“，String.Empty”）；
StringBuilder公式=新的StringBuilder（）；
对于（int i=0；i0&&（char）stack.Peek（）！='（'&&Prior（x）0&&（char）stack.Peek（）！='（'&&Prior（x）0）
{
char c=（char）stack.Pop（）；
公式。附加（c）；
}
返回公式.ToString（）；
}
静态布尔等参器（字符c）
{
返回值（c='-'| | c='+'| | c='*'| | c=='/'）；
}
静态布尔等径线（字符c）
{
return（c>='0'&&c在等运算符中，检查c=='-'。

但是在字符串中，你写−3.

− 与-

我不知道波兰语的东西，所以可能我遗漏了什么，但这就是为什么没有打印“-”运算符的原因，它没有通过等运算符检查并进入else子句，而else子句没有将它添加到公式中。
当你得到一个
）
时，你应该弹出所有运算符并将它们添加到公式中，直到你找到一个
（
，然后弹出该选项（“也一样

当您得到一个运算符时，只有当其优先级大于或等于
x
时，才应弹出堆栈并将该运算符添加到公式中。您的第二次检查是多余的，因为它已被第一次检查覆盖

作为一般规则：用一些简单的输入，比如
1+2+3
，
1+2-3
，
1*2+3
和
1+2*3
来尝试你的程序，看看你是否得到了正确的结果。像这样系统地测试应该可以帮助你更快地发现错误。
使用系统；
using System;
using System.Collections.Generic;
using System.Text;

class Sample {
    static void Main(string[] args){
        String str = "5 + ( ( 1 + 2 ) *  4 ) -3";
        String result=LengyelFormaKonvertalas(str);
        Console.WriteLine(result);
        Console.ReadLine();
    }

    static String LengyelFormaKonvertalas(String input){
       Stack<char> stack = new Stack<char>();
       String str = input.Replace(" ", string.Empty);
       StringBuilder formula = new StringBuilder();
       for (int i = 0; i < str.Length; i++){
           char x=str[i];
           if (x == '(')
               stack.Push(x);
           else if (x == ')'){
               while(stack.Count>0 && stack.Peek() != '(')
                   formula.Append(stack.Pop());
               stack.Pop();
           } else if (IsOperandus(x)){
               formula.Append(x);
           } else if (IsOperator(x)) {
               while(stack.Count>0 && stack.Peek() != '(' && Prior(x)<=Prior(stack.Peek()) )
                   formula.Append(stack.Pop());
               stack.Push(x);
           }
           else {
              char y= stack.Pop();
              if (y!='(') 
                  formula.Append(y);
           }
       }
       while (stack.Count>0) {
           formula.Append(stack.Pop());
       }
       return formula.ToString();
    }

    static bool IsOperator(char c){
        return (c=='-'|| c=='+' || c=='*' || c=='/');
    }
    static bool IsOperandus(char c){
        return (c>='0' && c<='9' || c=='.');
    }
    static int Prior(char c){
        switch (c){
            case '=':
                return 1;
            case '+':
                return 2;
            case '-':
                return 2;
            case '*':
                return 3;
            case '/':
                return 3;
            case '^':
                return 4;
            default:
                throw new ArgumentException("Rossz parameter");                                          
        }
    }
}

使用System.Collections.Generic；
使用系统文本；
类样本{
静态void Main（字符串[]参数）{
字符串str=“5+（（1+2）*4）-3”；
字符串结果=LengyelFormaKonvertalas（str）；
控制台写入线（结果）；
Console.ReadLine（）；
}
静态字符串LengyelFormaKonvertalas（字符串输入）{
堆栈=新堆栈（）；
String str=input.Replace（“，String.Empty”）；
StringBuilder公式=新的StringBuilder（）；
对于（int i=0；i0&&stack.Peek（）！='（'））
Append（stack.Pop（））；
stack.Pop（）；
}else if（等规数（x））{
公式。追加（x）；
}else if（等值线（x））{
while（stack.Count>0&&stack.Peek（）！='（'&&Prior（x）0）{
Append（stack.Pop（））；
}
返回公式.ToString（）；
}
静态布尔等参器（字符c）{
返回值（c='-'| | c='+'| | c='*'| | c=='/'）；
}
静态布尔等径线（字符c）{
return（c>='0'&&c如果x是一个运算符，您可以正确地检查堆栈顶部是否是另一个优先级较低/相等的运算符，但这应该是一个循环，而不是一个单独的测试。（或者我猜现在是一个双重检查，但它应该是一个循环）对不起，我是一个初学者程序员和英语学习者：）。您对它的理解是什么“应该是一个循环而不是一个单一测试”？我不知道我的程序中什么是单一测试：（你正在实现这个：对吗？在使用“等运算符”之后，你有了
if（stack.Count>0&&..
，那应该是
while
。我已经重写了，你说`（if（stack.Count…）到while（stack.Count…）“但这并没有解决问题。括号仍然添加到字符串中。（pdf中的结构图-算法，大约在第一季度，可能是调车场算法……我不知道我到底用了什么，它被匈牙利人称为波兰符号，可能是那所大学的教授弄错了：）谢谢，这是真的：）还有另一个符号，现在它是print it，现在它是print 2'（'symbolt他们是在上一段时间添加的，您可以
using System;
using System.Collections.Generic;
using System.Text;

class Sample {
    static void Main(string[] args){
        String str = "5 + ( ( 1 + 2 ) *  4 ) -3";
        String result=LengyelFormaKonvertalas(str);
        Console.WriteLine(result);
        Console.ReadLine();
    }

    static String LengyelFormaKonvertalas(String input){
       Stack<char> stack = new Stack<char>();
       String str = input.Replace(" ", string.Empty);
       StringBuilder formula = new StringBuilder();
       for (int i = 0; i < str.Length; i++){
           char x=str[i];
           if (x == '(')
               stack.Push(x);
           else if (x == ')'){
               while(stack.Count>0 && stack.Peek() != '(')
                   formula.Append(stack.Pop());
               stack.Pop();
           } else if (IsOperandus(x)){
               formula.Append(x);
           } else if (IsOperator(x)) {
               while(stack.Count>0 && stack.Peek() != '(' && Prior(x)<=Prior(stack.Peek()) )
                   formula.Append(stack.Pop());
               stack.Push(x);
           }
           else {
              char y= stack.Pop();
              if (y!='(') 
                  formula.Append(y);
           }
       }
       while (stack.Count>0) {
           formula.Append(stack.Pop());
       }
       return formula.ToString();
    }

    static bool IsOperator(char c){
        return (c=='-'|| c=='+' || c=='*' || c=='/');
    }
    static bool IsOperandus(char c){
        return (c>='0' && c<='9' || c=='.');
    }
    static int Prior(char c){
        switch (c){
            case '=':
                return 1;
            case '+':
                return 2;
            case '-':
                return 2;
            case '*':
                return 3;
            case '/':
                return 3;
            case '^':
                return 4;
            default:
                throw new ArgumentException("Rossz parameter");                                          
        }
    }
}