逆波兰表达式解数学运算(c#)

本文介绍了一个使用 C# 编写的计算器程序,该程序能够将中缀表达式转换为逆波兰表达式(后缀表达式),并对其进行求解。支持加减乘除及幂运算。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

本文用逆波兰表达式(后缀表达式)求解数学表达式(支持 + - * / % ^ ),用C#实现

求解步骤大致分为2步:

  1. 将中缀表达式转换成后缀表达式,例如表达式 1+3 转换成13+
  2. 求解后缀表达式得出结果

参考资料:

代码如下:
using System;
using System.Collections.Generic;
using System.Text;

namespace Calculate
{
    class Calculator
    {
        static Dictionary<char, int> priorities = null;
        const string operators = "+-*/%^";

        static Calculator()
        {
            priorities = new Dictionary<char, int>();
            priorities.Add('#', -1);
            priorities.Add('+', 0);
            priorities.Add('-', 0);
            priorities.Add('*', 1);
            priorities.Add('/', 1);
            priorities.Add('%', 1);
            priorities.Add('^', 2);
        }

        static double Compute(double leftNum, double rightNum, char op)
        {
            switch (op)
            {
                case '+': return leftNum + rightNum;
                case '-': return leftNum - rightNum;
                case '*': return leftNum * rightNum;
                case '/': return leftNum / rightNum;
                case '%': return leftNum % rightNum;
                case '^': return Math.Pow(leftNum, rightNum);
                default: return 0;
            }
        }

        static bool IsOperator(char op)
        {
            return operators.IndexOf(op) >= 0;
        }

        static bool IsLeftAssoc(char op)
        {
            return op == '+' || op == '-' || op == '*' || op == '/' || op == '%';
        }

        static Queue<object> PreOrderToPostOrder(string expression)
        {
            var result = new Queue<object>();
            var operatorStack = new Stack<char>();
            operatorStack.Push('#');
            char top, cur,tempChar;
            string tempNum;
            if (expression[0] == '-') expression = '0' + expression;

            for (int i = 0,j; i < expression.Length; )
            {
                cur = expression[i++];
                top = operatorStack.Peek();

                if (cur == '(')
                {
                    operatorStack.Push(cur);
                }
                else
                {
                    if (IsOperator(cur))
                    {
                        while(IsOperator(top) && ((IsLeftAssoc(cur)&& priorities[cur] <= priorities[top])) ||(!IsLeftAssoc(cur)&&priorities[cur]<priorities[top]))
                        {
                            result.Enqueue(operatorStack.Pop());
                            top = operatorStack.Peek();
                        }
                        operatorStack.Push(cur);
                    }
                    else if (cur == ')')
                    {
                        while (operatorStack.Count > 0 && (tempChar = operatorStack.Pop()) != '(')
                        {
                            result.Enqueue(tempChar);
                        }
                    }
                    else
                    {
                        tempNum = "" + cur;
                        j = i;
                        while (j < expression.Length && (expression[j] == '.' || (expression[j] >= '0' && expression[j] <= '9')))
                        {
                            tempNum += expression[j++];
                        }
                        i = j;
                        result.Enqueue(tempNum);
                    }
                }
            }
            while (operatorStack.Count > 0)
            {
                cur = operatorStack.Pop();
                if (cur == '#') continue;
                if (operatorStack.Count > 0)
                {
                    top = operatorStack.Peek();
                }
                
                result.Enqueue(cur);
            }
            
            return result;
        }

        static double Calucate(string expression)
        {
            try
            {
                var rpn = PreOrderToPostOrder(expression);
                var operandStack = new Stack<double>();
                double left, right;
                object cur;
                while (rpn.Count > 0)
                {
                    cur = rpn.Dequeue();
                    if (cur is char)
                    {
                        right = operandStack.Pop();
                        left = operandStack.Pop();
                        operandStack.Push(Compute(left, right, (char)cur));
                    }
                    else
                    {
                        operandStack.Push(double.Parse(cur.ToString()));
                    }
                }
                return operandStack.Pop();
            }
            catch
            {
                throw new Exception("表达式格式不正确!");
            }            
        }

        static void Main(string[] args)
        {
            string expression;
            Console.Write("输入表达式(支持+-*/%^),输入exit退出: ");
            while ((expression = Console.ReadLine()) != "exit")
            {
                try
                {
                    Console.WriteLine(expression + " = " + Calucate(expression));
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
                Console.Write("输入表达式(支持+-*/%^),输入exit退出: ");
            }
        }
    }
}

测试如下:


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值