C#实现中缀表达式转后缀表达式（RPN）并针对后者进行求值

最新推荐文章于 2024-04-23 07:20:05 发布
最新推荐文章于 2024-04-23 07:20:05 发布
阅读量2.8k 收藏 17
点赞数 2
分类专栏： C# 文章标签： RPN C# 中缀表达式 后缀表达式 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yujiaxucheng/article/details/79150556
版权

 最近因工作需要，用到“计算器”功能：输入一串文本，解析后进行计算。这部分只是作为一个简单的应用模块，而不是单独的程序，所以着重在算法的实现上。实际编码前，想过用栈、二叉树、循环递归等各种方法，但都否定掉了。一是因为给别人用的，感觉太复杂讲不清楚，二是我实现起来也有点麻烦。

 最终，高手阿毛一语惊醒梦中人，问我是不是想用“RPN”实现。

 RPN是啥？RPN就是逆波兰表达式，即后缀表达式。

正常人类计算公式都是形如：
3+4*2/(5-3)^2+3*(4-2)
COS(900-3*10*30)+123.45+30*30-0.45+TAN(0)
这样的算式，也就是中缀表达式，而比较方便计算机理解的是：
3,4,2,*,5,3,-,2,^,/,+,3,4,2,-,*,+
900,3,10,*,30,*,-,COS,123.45,+,30,30,*,+,0.45,-,0,TAN,+,
这样的后缀表达式(RPN)


效果如下：



所以，编码工作主要分为以下几块：
一、含有函数的中缀表达式转后缀表达式
    1）区分数字、函数名、运算符；
    2）将字符串拆分为数组形式，方便入栈；
    3）判断运算符、函数的优先级，正确排列顺序；
二、针对后缀表达式进行计算
    1）区分数字、函数名、运算符的不同操作；
    2）根据运算规则不同进行入栈、出栈和计算；


梳理计算流程：

图一：简单算术表达式的中缀转后缀


图二：带有函数名的表达式，中缀转后缀


图三：简单算术后缀表达式计算


图四：带有函数名的后缀表达式计算



具体实现代码： 
/*===================================*/
//RPN and calculate
/*是否为纯数字。正则表达式实现*/
public static bool isNumber(string tmp)
{
    return Regex.IsMatch(tmp, @"[0-9]+[.]{0,1}[0-9]*");
}


/*是否为需拆分的运算符+-*^/() */
public static bool isOp(string tmp)
{
    bool bRet = false;
    switch (tmp)
    {
        case "+":
        case "-":
        case "*":
        case "/":
        case "^":
        case "(":
        case ")":
            bRet = true;
            break;
        default:
            bRet = false;
            break;
    }
    return bRet;
}


/*是否为一元函数名*/
public static bool isFunc(string tmp)
{
    bool bRet = false;
    switch (tmp)
    {
        case "SIN":
        case "COS":
        case "TAN":
        case "SQRT":
            bRet = true;
            break;
        default:
            bRet = false;
            break;
    }
    return bRet;
}


/*比较运算符及函数优先级。函数视作运算符进行操作。
    返回值：1 表示 大于，-1 表示 小于，0 表示 相等    */
public static int compOper(string op1, string op2)
{
    int iRet = 0;
    Dictionary<string, int> dic = new Dictionary<string, int>();
    dic.Add("+", 1);
    dic.Add("-", 1);
    dic.Add("*", 2);
    dic.Add("/", 2);
    dic.Add("^", 3);
    dic.Add("SIN", 4);
    dic.Add("COS", 4);
    dic.Add("TAN", 4);
    dic.Add("SQRT", 4);
    dic.Add("(", 100);
    dic.Add(")", 100);
    if (dic[op1] > dic[op2])
        iRet = 1;
    else if (dic[op1] < dic[op2])
        iRet = -1;
    else
        iRet = 0;
    return iRet;
}


/*运算符、函数求值*/
public static double calValue(string op, string val1, string val2)
{
    double dRet = 0.0d;
    switch (op)
    {
        case "+":
            dRet = double.Parse(val1) + double.Parse(val2);
            break;
        case "-":
            dRet = double.Parse(val1) - double.Parse(val2);
            break;
        case "*":
            dRet = double.Parse(val1) * double.Parse(val2);
            break;
        case "/":
            if (double.Parse(val2) != 0)
                dRet = double.Parse(val1) / double.Parse(val2);
            else
                MessageBox.Show("Error!");
            break;
        case "^":
            dRet = Math.Pow(double.Parse(val1), double.Parse(val2));
            break;
        default:
            break;
    }
    return dRet;
}
public static double calValue(string op, string val1)
{
    double dRet = 0.0d;
    switch (op)
    {
        case "SIN":
            dRet = Math.Sin(double.Parse(val1));
            break;
        case "COS":
            dRet = Math.Cos(double.Parse(val1));
            break;
        case "TAN":
            dRet = Math.Tan(double.Parse(val1));
            break;
        case "SQRT":
            if (double.Parse(val1) > 0)
                dRet = Math.Sqrt(double.Parse(val1));
            else
                MessageBox.Show("Error!");
            break;
        default:
            break;
    }
    return dRet;
}


/*按照=+-*^/()分隔出元素*/
public static string splitFunc(string tmp)
{
    string sRet = tmp;
    sRet = sRet.Replace("=", "\n=\n");
    sRet = sRet.Replace("+", "\n+\n");
    sRet = sRet.Replace("-", "\n-\n");
    sRet = sRet.Replace("*", "\n*\n");
    sRet = sRet.Replace("/", "\n/\n");
    sRet = sRet.Replace("^", "\n^\n");
    sRet = sRet.Replace("(", "\n(\n");
    sRet = sRet.Replace(")", "\n)\n");
    return sRet;
}


/*中缀表达式转后缀表达式
    tmp为已经添加分隔符的中缀表达式字符串    */
public static string midToRPN(string tmp)
{
    string sRet = "";                                               //返回值
    string[] strArr = splitFunc(tmp.ToUpper()).Split('\n');         //字符串数组，存放分隔后的中缀表达式元素
    Stack<string> strStk = new Stack<string>();                     //栈，用于临时存放运算符和函数名
    for (int i = 0; i < strArr.Length; i++)
    {
        if (string.IsNullOrEmpty(strArr[i]))                        //分隔后为空的元素剔除
            continue;
        else if (calString.isNumber(strArr[i]))                     //纯数字直接入队列
            sRet += strArr[i] + ',';
        else if (calString.isFunc(strArr[i]))                   //一元函数名直接入栈
            strStk.Push(strArr[i]);
        else if (calString.isOp(strArr[i]))                         //运算符特殊处理
        {
            if (strStk.Count != 0 && strStk.Peek() == "(" && strArr[i] != ")")      //栈不为空，最上层为"("，则运算符直接入栈
            {
                strStk.Push(strArr[i]);
            }
            else if (strStk.Count != 0 && strArr[i] == ")")                         //栈不为空，遇")"则pop至"("为止
            {
                while (strStk.Peek() != "(")
                    sRet += strStk.Pop() + ',';
                strStk.Pop();
                if (strStk.Count != 0 && calString.isFunc(strStk.Peek()))       //若"("后为一元函数名，则函数名也pop出
                    sRet += strStk.Pop() + ',';
            }
            else if (strStk.Count != 0 && calString.compOper(strArr[i], strStk.Peek()) == -1)
            {                                                                       //栈不为空，运算符优先级小
                while (strStk.Count != 0 && strStk.Peek() != "(" && calString.compOper(strArr[i], strStk.Peek()) == -1)
                    sRet += strStk.Pop() + ',';                                     //则一直pop【存疑】
                if (strStk.Count != 0)                                              //pop至优先级不小于栈顶运算符则交换位置
                    sRet += strStk.Pop() + ',';                                     //先pop
                strStk.Push(strArr[i]);                                             //再push
            }
            else if (strStk.Count != 0 && calString.compOper(strArr[i], strStk.Peek()) == 0)
            {                                                                       //运算符优先级相同，先pop再push
                sRet += strStk.Pop() + ',';
                strStk.Push(strArr[i]);
            }
            else if (strStk.Count != 0 && calString.compOper(strArr[i], strStk.Peek()) == 1)
            {                                                                       //运算符优先级大，直接入栈
                strStk.Push(strArr[i]);
            }
            else                                                                    //其他情况，入栈【存疑】
            {
                strStk.Push(strArr[i]);
            }
        }
    }
    while (strStk.Count > 0)                //最后栈内元素全部pop出
    {
        sRet += strStk.Pop() + ',';
    }
    return sRet;                            //返回后缀表达式
}


/*根据传入的后缀表达式，求值
    tmp为含,分隔符的后缀表达式 */
public static double calRPN(string tmp)
{
    double dRet = 0.0d;
    string[] strArr = tmp.Split(',');
    Stack<string> strStk = new Stack<string>();
    for (int i = 0; i < strArr.Length - 1; i++)
    {
        if (isNumber(strArr[i]))                //纯数字入栈
            strStk.Push(strArr[i]);
        else if (isOp(strArr[i]))               //二元运算符，pop两个元素，计算值后压入栈
            strStk.Push(calValue(strStk.Pop(), strStk.Pop(), strArr[i]).ToString());
        else if (isFunc(strArr[i]))         //一元函数名，pop一个元素，计算后压入栈
            strStk.Push(calValue(strArr[i], strStk.Pop()).ToString());
    }
    dRet = double.Parse(strStk.Pop());          //取最后栈中元素作为结果值
    return dRet;
}
/*===================================*/


/*===================================*/
/*调用部分代码*/
private void btnTrans_Click(object sender, EventArgs e)
{
    //中缀表达式转后缀表达式
    this.tbRPN.Text = calString.midToRPN(this.tbOrigin.Text);
}


private void btnCal_Click(object sender, EventArgs e)
{
    //后缀表达式求值
    double tmp;
    try
    {
        tmp = calString.calRPN(this.tbRPN.Text);
        this.tbRes.Text = tmp.ToString();
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.ToString());
        this.tbRes.Text = "Error";
    }
    finally
    {


    }
}
/*===================================*/
文章地址： https://mp.weixin.qq.com/s/Zdof-uGtQ0CylF544ZYbUA

yujiaxucheng
关注
  • 2
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
c#的中缀表达式转化为逆波兰式（后缀表达式）
05-17
使用c#写的一个将中缀表达式转化为后缀表达式。实现手法是使用一个栈。
表达式求值（根据原表达式得到后缀表达式计算）
11-02
表达式求值（根据原表达式得到后缀表达式计算） 表达式中只限输入整数
excel中数据粘贴到txt中列对齐的方式
nercon233的专栏
06-19 1万+
有时我们处理excel数据，想吧数据粘贴到txt文本文件中进行列编辑处理时，会发现粘贴之后的列没有对齐，不好进行列编辑，有什么好的解决办法呢？ 方法如下：1、在把要excel另存为.rpn文件（带格式的文本文件），2、把.rpn文件后缀改为.txt文件即可。 注意点：最好excel中每列都是左对齐。 ...
C#实现中缀表达式转后缀表达式以及运算
RoySummy的博客
09-10 968
思路 中缀表达式转后缀表达式 初始化两个栈，运算符栈s1和储存中间结果的栈s2 从左到右扫描中缀表达式 遇到数字则压入s2中 遇到运算符{ – 1.如果s1为空，或栈顶运算符为左括号，则直接将此运算符压入s1 – 2.若优先级比栈顶运算符高，也压入s1 – 3.否则，将栈顶的运算符弹出并压入s2中，再次转到 4.1 与s1中新的栈顶运算符比较 } 遇到括号 { –1. 如果是左括号，则直接压入s1 –2. 如果是右括号，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃 }
MIDI文件(1)
知识-精神的力量
07-28 6699
MIDI 文件属于二进制文件,这种文件一般都有如下基本结构: 文件头+数据描述 文件头一般包括文件的类型,因为 Midi 文件仅以.mid 为扩展名的就有 0 类和 1 类两种,而大家熟悉的位 图文件的格式就更多了,所以才会出现文件头这种东西。 而数据描述部份是主体,我们现在来一起分析它的结构: 在每个 Midi 文件的开头都有如下内容,它们的十六进制代码为:“4d 54 68 64 00
中缀表达式转后缀表达式
热门推荐
qianyayun19921028的博客
04-12 9万+
自从找完工作人就废了，幡然醒悟不行不行，得把忘记的都记下来。。。。。。 中缀表达式就是我们正常使用的那种，例如：a+b*c 后缀表达式就是abc*+； 为什么要有中缀表达式和后缀表达式呢？ 因为中缀表达式便于人们的理解与计算，但是后缀表达式更方便计算机的运算（如二叉树、堆栈的方法计算），因此在读取一个中缀表达式后，我们得办法将他转化为后缀表达式。 转化方式有三种： 首先假设我们需要转化...
C#数据结构-前缀中缀后缀+中缀转后缀
nameyichao的博客
11-05 959
2）要想知道前缀表达式怎么写，需要先了解前缀表达式在计算机中是怎样求值的：从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们进行相应的计算，并将结果入栈；：理解的时候用两个栈更好理解，实际写代码过程中，只需要初始化一个栈(s1)和一个集合(s2)，那为什么另一个栈（s2）变成集合更好，因为变成集合后，就可以不用逆序就是最后的后缀表达式（可以直接用），如果s2用栈的话，最后弹出后，还需要再逆序一下才为后缀表达式。1）如果遇到左括号“（ ”，直接压入s1。
中缀表达式转RPN
Devil_DiabLo的博客
01-15 240
文章目录1.题目2.数据结构与算法3.源代码4.时间复杂度5.结论 1.题目 中缀表达式转RPN 2.数据结构与算法 DS:stack Algorithm: 参考我的上一篇文章：《中缀表达式求值 延迟缓冲》 只需对其代码进行扩充，即可得到中缀表达式转RPN的算法。 扩充内容（可以使用文本对比工具） 扫描中缀表达式： 当遇到数字，将数字追加到RPN后。 当遇到符号，若执行计算(即>分支)，则将栈顶符号追加到RPN后。 3.源代码 #include "stdafx.h" #include <ios
使用C#完成中缀表达式转化为后缀表达式（代码）
weixin_43549003的博客
08-04 2860
第一步：确定优先级的函数,其中（ 优先级最低。 public Boolean Priority(char ch1, char ch2) { switch (ch1) { case '(': code1 = 1; break; case '+': case '-':
C# 表达式求值，字符串表达式求值
05-21
字符串表达式求值 输入类似1+2+3，6*5/7的字符串，计算出值
C#表达式求值
06-16
实现中缀表达式转为后缀表达式，并实现计算，有界面。
C#.NET逆波兰算法求解普通算式(支持自定义运算符)
12-10
用法举例： using System; using System.Collections.Generic; using RPN; namespace CSharp_Console { class Program { public static void Main(string[] args) { var rpn = new ReversePolishNotation(); rpn.AddOperation(new Power('^', "乘方", 5)); rpn.AddOperation(new E('e', "科学记数法", 5)); var expression = "3^6 +78*345+3-345/3e(-2)*(-9+3-5*7)"; try { Console.WriteLine(rpn.RpnExpression(expression)); Console.WriteLine(rpn.Calculate(expression)); } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.ReadKey(); } }
c语言实现中缀表达式转后缀并求值
04-09
c语言实现中缀表达式转后缀表达式并求得计算结果，用顺序栈结构。 当输入者输入错误信息的时候需要报错，并说明错误的种类。
C++实现中缀表达式转后缀表达式
08-19
主要为大家详细介绍了C++实现中缀表达式转后缀表达式，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C++利用栈实现中缀表达式转后缀表达式
12-20
本文实例为大家分享了C++实现中缀表达式转后缀表达式的具体代码，供大家参考，具体内容如下 题目：现有中缀表达式如：1+(2-3)*4+10/5 请用栈的特性编写一个程序，使得程序输出后缀表达式 分析如下： STEP1： 1+(2-3)...
中缀表达式转后缀并求值
10-31
C++的代码中缀表达式转后缀然后求值，数据结构方面的。
135. 分发糖果
最新发布
yinhua405的博客
04-23 719
//和前一个不相等。你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。///和前一个不相等。///和前一个不相等。///和前一个不相等。请你给每个孩子分发糖果，计算并返回需要准备的。
【Leetcode】2007. 从双倍数组中还原原数组
weixin_43627638的博客
04-19 299
一个整数数组original可以转变成一个数组changed，转变方式为将original中每个元素加入数组中，然后将所有元素。给你一个数组changed，如果change是数组，那么请你返回original数组，否则请返回空数组。original的元素可以以顺序返回。
算法刷题-16
qq_45773834的博客
04-21 625
学习来源： leetcode，牛客 https://programmercarl.com https://www.yuque.com/taxing-qarr6/hxitgt/dedugmp09knerdi1
中缀表达式转后缀表达式并求值
09-12
中缀表达式转后缀表达式并求值是一种常见的数学计算方法。通过将中缀表达式转换为后缀表达式，我们可以更方便地对表达式进行计算。要完成这个任务，可以使用堆栈的方法。 首先，需要定义运算符的优先级。在计算机中，通常将运算符的优先级定义为一个数字，数字越大，优先级越高。常见的运算符包括加减乘除和括号。 接下来，遍历中缀表达式的每个字符： 1. 如果是数字，直接输出到后缀表达式。 2. 如果是左括号，入栈。 3. 如果是右括号，将栈中的运算符依次弹出并输出到后缀表达式，直到遇到左括号，将左括号从栈中弹出。 4. 如果是运算符，比较与栈顶运算符的优先级： a. 如果栈为空或栈顶为左括号，则将当前运算符入栈。 b. 如果当前运算符的优先级大于栈顶运算符的优先级，则将当前运算符入栈。 c. 否则，将栈顶运算符弹出并输出到后缀表达式，然后重复步骤4，直到满足条件。 5. 遍历完中缀表达式后，如果栈不为空，将栈中剩余的运算符依次弹出并输出到后缀表达式。 得到后缀表达式后，就可以通过遍历后缀表达式的每个字符来求值： 1. 如果是数字，入栈。 2. 如果是运算符，弹出栈顶的两个数字进行相应的运算，并将结果入栈。 3. 遍历完后缀表达式后，栈顶的数字即为最终的计算结果。 通过以上步骤，我们可以实现中缀表达式转后缀表达式并求值的功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值