C# 如何利用C语言中的堆栈计算中缀表达式的输出#

我已经在Stackoverflow上找到了不同的解决方案，但有些事情我不明白

例如：（1+（4*（2+3））+（（2+3）*（4*5）），计算产量的最佳方法是什么

我的方法如下，但我知道其中有很多错误：

public static int ComputeInfix(string infix) {
        Stack<char> operatorstack = new Stack<char>();
        Stack<int> operandstack = new Stack<int>();
        for(int j = 0; j < infix.Length; j++) {
            char c = infix[j];
            if (c => 0 && c <= 9) {
                operandstack.Push(c);
            }
            else if ((c == '+' || c == '*' ||  c == '/' || c == '-')) {
                if (operatorstack.IsEmpty()) {
                    operatorstack.Push(c);
                }
                else {
                    if (operatorstack.Peek() != '*' || operatorstack.Peek() != '/') {
                        operatorstack.Push(c);
                    }
                }
            } 
            else if (c == '(') {
                operatorstack.Push(c);
            }
            else if (c == ')') {
                operatorstack.Pop();
            }
        }
        return infix;
    }

publicstaticintcomputeinfix（字符串中缀）{
堆栈运算符堆栈=新堆栈（）；
堆栈操作数堆栈=新堆栈（）；
对于（int j=0；j如果（c=>0&&c'0'&&c，因为我花了时间来写它，下面是我的解决方案：

public static int ComputeInfix(string infix) {
    var operatorstack = new Stack<char>();
    var operandstack = new Stack<int>();

    var precedence = new Dictionary<char, int> { { '(', 0 }, { '*', 1 }, { '/', 1 }, { '+', 2 }, { '-', 2 }, { ')', 3 } };

    foreach (var ch in $"({infix})") {
        switch (ch) {
            case var digit when Char.IsDigit(digit):
                operandstack.Push(Convert.ToInt32(digit.ToString()));
                break;
            case var op when precedence.ContainsKey(op):
                var keepLooping = true;
                while (keepLooping && operatorstack.Count > 0 && precedence[ch] > precedence[operatorstack.Peek()]) {
                    switch (operatorstack.Peek()) {
                        case '+':
                            operandstack.Push(operandstack.Pop() + operandstack.Pop());
                            break;
                        case '-':
                            operandstack.Push(-operandstack.Pop() + operandstack.Pop());
                            break;
                        case '*':
                            operandstack.Push(operandstack.Pop() * operandstack.Pop());
                            break;
                        case '/':
                            var divisor = operandstack.Pop();
                            operandstack.Push(operandstack.Pop() / divisor);
                            break;
                        case '(':
                            keepLooping = false;
                            break;
                    }
                    if (keepLooping)
                        operatorstack.Pop();
                }
                if (ch == ')')
                    operatorstack.Pop();
                else
                    operatorstack.Push(ch);
                break;
            default:
                throw new ArgumentException();
        }
    }

    if (operatorstack.Count > 0 || operandstack.Count > 1)
        throw new ArgumentException();

    return operandstack.Pop();
}

publicstaticintcomputeinfix（字符串中缀）{
var operatorstack=新堆栈（）；
var operandstack=新堆栈（）；
变量优先级=新字典{{（'，0}，{'*'，1}，{'/'，1}，{'+'，2}，{'-'，2}，{''''，3}；
foreach（var ch，单位为“（{infix}）”）{
开关（ch）{
字符为数字时的大小写变量数字（数字）：
操作数堆栈.Push（Convert.ToInt32（digit.ToString（））；
打破
优先级为时的案例变量op.ContainsKey（op）：
var keeploping=true；
while（keeploping&&operatorstack.Count>0&&priority[ch]>priority[operatorstack.Peek（））{
开关（operatorstack.Peek（））{
格“+”：
操作数堆栈.Push（操作数堆栈.Pop（）+操作数堆栈.Pop（））；
打破
案例'-'：
操作数堆栈.Push（-operanstack.Pop（）+operanstack.Pop（））；
打破
案例“*”：
操作数堆栈.Push（操作数堆栈.Pop（）*操作数堆栈.Pop（））；
打破
案例“/”：
变量除数=操作数堆栈.Pop（）；
操作数堆栈.Push（操作数堆栈.Pop（）/除数）；
打破
格“（”：
keeploping=false；
打破
}
如果（保持打开）
运算符stack.Pop（）；
}
如果（ch=='）'）
运算符stack.Pop（）；
其他的
操作器固定推力（ch）；
打破
违约：
抛出新ArgumentException（）；
}
}
if（运算符stack.Count>0 | |操作数堆栈.Count>1）
抛出新ArgumentException（）；
返回操作数stack.Pop（）；
}
现在将其更改为：
（c=>'0'&&c行
c=>0&&c您可以执行
char.IsDigit（c）
我不知道你的代码是如何编译的。举个简单的例子，你返回
字符串中缀
参数作为函数的
int
结果。你没有将字符串转换/解释为整数的操作。你没有执行操作。至少试着发布编译的代码。@KárolyOzsvárt你正确吗ct，我总是希望周围的
（）
-修复。
public static int ComputeInfix(string infix) {
    var operatorstack = new Stack<char>();
    var operandstack = new Stack<int>();

    var precedence = new Dictionary<char, int> { { '(', 0 }, { '*', 1 }, { '/', 1 }, { '+', 2 }, { '-', 2 }, { ')', 3 } };

    foreach (var ch in $"({infix})") {
        switch (ch) {
            case var digit when Char.IsDigit(digit):
                operandstack.Push(Convert.ToInt32(digit.ToString()));
                break;
            case var op when precedence.ContainsKey(op):
                var keepLooping = true;
                while (keepLooping && operatorstack.Count > 0 && precedence[ch] > precedence[operatorstack.Peek()]) {
                    switch (operatorstack.Peek()) {
                        case '+':
                            operandstack.Push(operandstack.Pop() + operandstack.Pop());
                            break;
                        case '-':
                            operandstack.Push(-operandstack.Pop() + operandstack.Pop());
                            break;
                        case '*':
                            operandstack.Push(operandstack.Pop() * operandstack.Pop());
                            break;
                        case '/':
                            var divisor = operandstack.Pop();
                            operandstack.Push(operandstack.Pop() / divisor);
                            break;
                        case '(':
                            keepLooping = false;
                            break;
                    }
                    if (keepLooping)
                        operatorstack.Pop();
                }
                if (ch == ')')
                    operatorstack.Pop();
                else
                    operatorstack.Push(ch);
                break;
            default:
                throw new ArgumentException();
        }
    }

    if (operatorstack.Count > 0 || operandstack.Count > 1)
        throw new ArgumentException();

    return operandstack.Pop();
}