笔记大全

C怎么利用后缀表达式解析计算字符串公式

更新时间：2023-09-09

什么是后缀表达式

后缀表达式（也叫逆波兰表达式）是一种不需要括号即可表示完整表达式的计算法则。通俗来说，后缀表达式就是把操作数放前面，操作符放后面，依次排列，并去掉所有括号的一种表达式。例如，中缀表达式（3+4）* 5-6在后缀表达式中就变成了3 4 + 5 * 6 -。

如何利用后缀表达式计算字符串公式

要利用后缀表达式计算字符串公式，需要经过以下几个步骤：

1. 将中缀表达式转换为后缀表达式。这个可以使用栈来实现。

public static string InfixToPostfix(string expression)
{
    StringBuilder postfix = new StringBuilder();
    Stack stack = new Stack();
    Dictionary operators = new Dictionary();
    operators.Add('-', 1);
    operators.Add('+', 1);
    operators.Add('*', 2);
    operators.Add('/', 2);
    operators.Add('^', 3);

    for (int i = 0; i < expression.Length; i++)
    {
        char c = expression[i];
        if (Char.IsWhiteSpace(c))
        {
            continue;
        }
        else if (Char.IsDigit(c) || c == '.')
        {
            postfix.Append(c);
            while (i + 1 < expression.Length && (Char.IsDigit(expression[i + 1]) || expression[i + 1] == '.'))
            {
                postfix.Append(expression[i + 1]);
                i++;
            }
            postfix.Append(" ");
        }
        else if (c == '(')
        {
            stack.Push(c);
        }
        else if (c == ')')
        {
            while (stack.Peek() != '(')
            {
                postfix.Append(stack.Pop());
            }
            stack.Pop();
        }
        else
        {
            while (stack.Count > 0 && operators.ContainsKey(stack.Peek()) && operators[stack.Peek()] >= operators[c])
            {
                postfix.Append(stack.Pop());
            }
            stack.Push(c);
        }
    }

    while (stack.Count > 0)
    {
        postfix.Append(stack.Pop());
    }

    return postfix.ToString();
}

2. 遍历后缀表达式，将每个操作数和操作符入栈，当遍历到操作符时，弹出栈中的两个操作数并运算，将计算结果压入栈中。

public static double CalculatePostfix(string expression)
{
    Stack stack = new Stack();
    for (int i = 0; i < expression.Length; i++)
    {
        char c = expression[i];
        if (Char.IsWhiteSpace(c))
        {
            continue;
        }
        else if (Char.IsDigit(c) || c == '.')
        {
            StringBuilder operand = new StringBuilder();
            operand.Append(c);
            while (i + 1 < expression.Length && (Char.IsDigit(expression[i + 1]) || expression[i + 1] == '.'))
            {
                operand.Append(expression[i + 1]);
                i++;
            }
            stack.Push(double.Parse(operand.ToString()));
        }
        else
        {
            double operand2 = stack.Pop();
            double operand1 = stack.Pop();
            switch (c)
            {
                case '-':
                    stack.Push(operand1 - operand2);
                    break;
                case '+':
                    stack.Push(operand1 + operand2);
                    break;
                case '*':
                    stack.Push(operand1 * operand2);
                    break;
                case '/':
                    stack.Push(operand1 / operand2);
                    break;
                case '^':
                    stack.Push(Math.Pow(operand1, operand2));
                    break;
            }
        }
    }
    return stack.Pop();
}

代码规范

在处理表达式计算时，为了保证代码的可读性和可维护性，需要遵守以下规范：

变量和方法的命名要有意义，建议使用驼峰命名法。
代码要注重可读性，尽量不要写一些过于晦涩难懂的代码。
要注意代码的健壮性，尽量考虑所有边缘情况。
代码要符合语言的编码规范，遵循一些常用的编写方式，例如在if语句的条件中，常常把常数放在等式左侧，以避免写成赋值语句而不是比较语句。

总结

利用后缀表达式解析计算字符串公式可以通过将中缀表达式转换为后缀表达式，再遍历后缀表达式进行计算。在编写代码时需要注意代码的可读性、可维护性和健壮性。还需要遵循语言的编码规范，采用常用的编码方式。在实际应用中，还需要注意一些边缘情况，以保证程序的正确性和稳定性。

c语言编程笔录