C#数学表达式计算（中缀转换后缀）数据结构括号四则运算幂运算取模三角函数

阳光穿透心脏的1/2处 2022-05-06 03:58 324阅读 0赞

## 前言： ##

1.遇到操作数，直接输出；  
2.栈为空时，遇到运算符，入栈；  
3.遇到左括号，将其入栈；  
4.遇到右括号，执行出栈操作，并将出栈的元素输出，直到弹出栈的是左括号，左括号不输出； (左括号丢弃 不输出)  
5.遇到其他运算符 + - \* / 时，弹出所有优先级大于或等于该运算符的栈顶元素，然后将该运算符入栈；  
6.最终将栈中的元素依次出栈，输出。  
全文地址请点击：https://blog.csdn.net/qq\_34992845/article/details/70313588?utm\_source=copy

后缀表达式的计算：从左到右遍历表达式的每个数字和符号，遇到是数字就进栈，遇到是符号，就将处于栈顶两个数字出栈，进行运算，运算结果进栈，一直到最终获得结果。

如何区分负号与减号  
如果“-”是第一个字符时｛  
在前面加上“0-”  
｝  
否则｛  
如果“-”前一个字符是数字 “-”是减号  
如果“-”前一个字符是“^”幂运算符 “-”是负号  
否则在前面加上“0-”  
｝  
如-1-(-4^2)  
会转换成0-1-(0-4^2)来处理

三角函数的运算思路（这里用的是角度制）  
输入式子->转换成小写->转换成运算符->计算  
如输入Sin(30)  
转换成小写sin(30)  
转换成运算符s(30)  
运算0.5  
![在这里插入图片描述][70]

## 代码： ##

若有不正之处，请多多谅解并欢迎指正。

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace 计算表达式
    {
        
        class Program
        {
        
            static void Errorchecking(string s,double d) {
        
                double a= Calculation(s);
                Console.WriteLine(string.Format("{0}        计算结果{1}  正确结果{2}   ",s,a,d));
            }
            
            static void Main(string[] args)
            {
        
                /*
                容易出错的式子：
                -2*(5-2)=-6
                -2*(-2)=4
                1-(-4^2)=17
                1+(-4^-2)=0.9375
                1+(-4)^-2=1.0625
    
                 */
    
                Errorchecking("-2 * (5 - 2)" ,-6);
                Errorchecking("-2*(-2)" , 4);
                Errorchecking("-64*(-4)^(-2)" , -4);
                Errorchecking("1-(-4^2)" , 17);
                Errorchecking("-1+(-4^-2)" , -1.0625);
                Errorchecking("1+(-4)^-2" , 1.0625);
                Errorchecking("Sin(90)", 1);
                Errorchecking("1-4*Sin(-1*(-2^5+2))", -1);
                Errorchecking("8*sin(-1*(-2^5+2))^2", 2);
                Errorchecking("cos60*4", 2);
                Errorchecking("tan(44+1)", 1);
                Console.WriteLine(string.Format("{0}        计算结果{1}  正确结果{2}   ", "tan(90)", Calculation("tan(90)"), "不存在的"));
    
                //Console.WriteLine(Calculation("S(-30)"));
    
            }
            public static double Calculation(string str)//函数已封装好 用到的时候直接调用该方法ok
            {
        
                //Console.WriteLine("中缀表达式:"+str);
                str=str.ToLower();//把字符串转换成小写
                RemoveSpaces(ref str);
                StrPreprocessing(ref str);
                //Console.WriteLine("中缀表达式:" + str + " 预处理");
    
                List<object> list = ToPostfix(str); //转换成中缀表达式
                return CalculationPostfix(list);
            }
            static double CalculationPostfix(List<object>list)//计算后缀表达式
            {
        
                List<double> stacks = new List<double>();
                //计算后缀表达式
                for (int i = 0; i < list.Count; i++)
                {
        
                    if (list[i] is double)
                    {
        
                        stacks.Add((double)list[i]);
                    }
                    else
                    {
        
                        string c = (string)list[i];
                        double aa, bb;
                        switch (c)
                        {
        
                            case "s":
                                aa = stacks.Last();
                                stacks.RemoveAt(stacks.Count - 1);
                                stacks.Add(Math.Sin(aa*Math.PI/180));//这里用的是角度制 弧度制的话改成Math.Sin(aa)就行了
                                break;
                            case "c":
                                aa = stacks.Last();
                                stacks.RemoveAt(stacks.Count - 1);
                                stacks.Add(Math.Cos(aa * Math.PI / 180));
                                break;
                            case "t":
                                aa = stacks.Last();
                                stacks.RemoveAt(stacks.Count - 1);
                                stacks.Add(Math.Tan(aa * Math.PI / 180));
                                break;
                            default:
                                bb = stacks.Last();
                                stacks.RemoveAt(stacks.Count - 1);
                                aa = stacks.Last();
                                stacks.RemoveAt(stacks.Count - 1);
                                stacks.Add(Operation(aa, bb, c));
                                break;
                        }
                    }
                }
                return stacks[0];//返回计算结果
            }
            static List<object> ToPostfix(string infix)//转换成后缀表达式
            {
        
                List<object> list = new List<object>();//一个集合
                List<string> stacks = new List<string>();//用来存符号的栈
                int len = infix.Length;
                int a = 0, b = 0;
                for (int i = 0; i < len; i++)
                {
        
                    //该for循环作用是 把字符串的数字括号运算符区分开来并添加到集合list
                    string c = infix.Substring(i, 1);
                    if (IsNum(c))
                    {
        
                        b++;
                        if (i == len - 1) list.Add(ParseNum(infix.Substring(a, b)));
                    }
                    else
                    {
        
                        string sum = infix.Substring(a, b);
                        if (sum.Length != 0) list.Add(ParseNum(sum));
                        a = i + 1;
                        b = 0;
                    }
                    switch (c) //符号栈操作
                    {
        
                        case "(": stacks.Add(c); break;
                        case ")":
                            while (stacks.Count > 0)
                            {
        
                                if (stacks.Last() != "(")
                                {
        
                                    list.Add(stacks.Last());
                                    stacks.RemoveAt(stacks.Count - 1);
                                }
                                else
                                {
        
                                    stacks.RemoveAt(stacks.Count - 1);
                                    break;
                                }
                            }
                            break;
                        case "+":
                        case "-":
                        case "*":
                        case "/":
                        case "%":
                        case "^":
                        case "s":
                        case "c":
                        case "t":
                            while (stacks.Count > 0)
                            {
        
                                if (Priority(c, stacks.Last()))
                                {
        
                                    list.Add(stacks.Last());
                                    stacks.RemoveAt(stacks.Count - 1);
                                }
                                else break;
                            }
                            stacks.Add(c);
                            break;
                    }
    
                }
                while (stacks.Count > 0) //最后的出栈
                {
        
                    list.Add(stacks.Last());
                    stacks.RemoveAt(stacks.Count - 1);
                }
                //Console.Write("后缀表达式:");
                //for (int i = 0; i < list.Count; i++) Console.Write(list[i]);
                return list;
            }
            static void StrPreprocessing(ref string infix)//字符串预处理
            {
        
                int len = infix.Length; 
                StringBuilder str = new StringBuilder();
    
                //把sin cos tan分别改为s c t方便后面的运算
                while (infix.IndexOf("sin") >=0 || infix.IndexOf("cos") >=0 || infix.IndexOf("tan") >=0)
                {
        
                    int a = infix.IndexOf("sin");
                    if(a!=-1) infix=infix.Remove(a+1,2);
                    a = infix.IndexOf("cos");
                    if (a != -1) infix=infix.Remove(a + 1, 2);
                    a = infix.IndexOf("tan");
                    if (a != -1) infix=infix.Remove(a + 1, 2);
                }
                
                len = infix.Length;
                str = new StringBuilder();
                for (int i = 0; i < len; i++)
                {
        
                    string c = infix.Substring(i, 1);
                    if (c == "-")
                    {
        
                        if (i == 0)
                        {
        
                            str.Append("0-");
                        }
                        else
                        {
        
                            string cc = infix.Substring(i - 1, 1);
                            if (IsNum(cc))
                            {
        
                                str.Append(c);
                            }
                            else if (cc == "^")
                            {
         //避免2^-2=0.25转换成2^0-2=-1
                                str.Append("_");
                            }
                            else
                            {
        
                                // str+="_";
                                str.Append("0-");
                            }
                        }
                    }
                    else str.Append(c);
                }
                infix = str.ToString();
    
            }
            static void RemoveSpaces(ref string infix)//删除空格
            {
        
                int len = infix.Length;
                StringBuilder str = new StringBuilder();//https://blog.csdn.net/qq_28187979/article/details/76607253
                //删除空格
                for (int i = 0; i < len; i++)
                {
        
                    string c = infix.Substring(i, 1);
                    if (c == " ") continue;
                    str.Append(c);
                }
                infix = str.ToString();
            }
            static double Operation(double a,double b,string c)//运算
            {
        
                switch (c)
                {
        
                    case "+": return a + b;
                    case "-": return a - b;
                    case "*": return a * b;
                    case "/": return a / b;
                    case "%": return a % b;
                    case "^": return Math.Pow(a, b);
                }
                throw new Exception();
            } 
            static bool Priority(string a,string b)//优先级判断
            {
        
                //true为a优低于b
                if (Grade(a) <= Grade(b)) return true;
                return false;
            }
            static int Grade(string s)//返回该运算符的等级
            {
        
                switch (s)
                {
        
                    case "(": return 0;
                    case "-": 
                    case "+": return 1;
                    case "/":
                    case "*":
                    case "%": return 2;
                    case "^": return 3;
                    case "s":
                    case "c":
                    case "t": return 4;
                    case ")": return 5;
                }
                return -1;
            }
            static bool IsNum(string s)//传入一个字符 判断该字符是不是数字。负号和点也属于数字 -3.14
            {
        
                switch (s)
                {
        
                    case "_"://预处理之后负号(-)转换成_  减号-不变
                    case "0":
                    case "1":
                    case "2":
                    case "3":
                    case "4":
                    case "5":
                    case "6":
                    case "7":
                    case "8":
                    case "9":
                    case ".": return true;
                }
                return false;
            }
            static bool IsSymbol(object s)//传入一个字符 判断该字符是不是符号
            {
        
                switch (s)
                {
        
                    case "+":
                    case "-":
                    case "*":
                    case "/":
                    case "%":
                    case "^":
                    case "s":
                    case "c":
                    case "t":
                        return true;
                }
                return false;
            }
            static double ParseNum(string num)//string转换double 在double.Parse(str);的基础上处理
            {
        
                if (num.Length > 0)
                {
        
                    if (num.Substring(0, 1) == "_") return -double.Parse(num.Substring(1, num.Length - 1));
                    else return double.Parse(num.Substring(0, num.Length));
                }
                throw new Exception();
            }
        }
    }

[70]: /images/20220506/b03481611161455f95bb9e5f03df0158.png