C#利用栈实现字符串运算解析

附上参考文章链接：https://blog.csdn.net/qq_34831781/article/details/80104219

本人整合修复一些bug后的代码

 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Text;

 // 解析计算字符串公式
 namespace CalcuStrFormula
 {
     // 处理类
     class Handler
     {
         private Stack _complexNumberStack = new Stack();
         private Stack _operatorStack = new Stack();
         private Parser _parser = new Parser();
         private Operators _operators = new Operators();

         private static Handler _instance;
         public static Handler instance
         {
             get
             {
                 if (_instance == null)
                 {
                     _instance = new Handler();
                 }
                 return _instance;
             }
         }

         public ComplexNumber Process(string inputString)
         {
             _complexNumberStack.Clear();
             _operatorStack.Clear();

             Queue<object> queue = _parser.Parse(inputString);
             ComplexNumber complexNumber = null;
             char op, topOp;
             int count = queue.Count;
             for (int i = ; i < count; i++)
             {
                 object obj = queue.Dequeue();
                 if (obj is char)
                 {
                     op = (char)obj;
                     if (_operatorStack.Count == )
                     {
                         _operatorStack.Push(op);
                     }
                     else
                     {
                         topOp = (char)_operatorStack.Peek();
                         if (op == '(')
                         {
                             _operatorStack.Push(op);  // 左括号直接压入。不判断栈顶
                         }
                         else if (op == ')')
                         {
                             // 右括号压入前观察栈顶，若栈顶是左括号，则弹出栈顶的左括号
                             // 否则弹出栈顶运算符，从数栈中弹出操作数进行运算，并将结果重新压入数栈，直到遇到左括号
                             while ((topOp = (char)_operatorStack.Pop()) != '(')
                             {
                                 ComplexNumber c1 = (ComplexNumber)_complexNumberStack.Pop(); // 符号右边数
                                 ComplexNumber c2 = null; // 符号左边数
                                 if (_operators.IsTwoNumOperator(topOp))
                                 {
                                     c2 = (ComplexNumber)_complexNumberStack.Pop();
                                 }
                                 ComplexNumber c3 = _operators.Compute(topOp, c2, c1);
                                 _complexNumberStack.Push(c3);
                             }
                         }
                         else if (_operators.ComparePriority(topOp, op) <= )
                         {
                             // 若即将压入的运算符不是括号，则比较栈顶运算符和即将压入的运算符的优先级
                             // 如果栈顶优先级高，则将栈顶运算符取出运算，直到栈顶优先级不大于其。
                             while (_operatorStack.Count !=  && _operators.ComparePriority((char)_operatorStack.Peek(), op) <= )
                             {
                                 topOp = (char)_operatorStack.Pop();
                                 ComplexNumber c1 = (ComplexNumber)_complexNumberStack.Pop(); // 符号右边数
                                 ComplexNumber c2 = null; // 符号左边数
                                 if (_operators.IsTwoNumOperator(topOp))
                                 {
                                     c2 = (ComplexNumber)_complexNumberStack.Pop();
                                 }
                                 ComplexNumber c3 = _operators.Compute(topOp, c2, c1);
                                 _complexNumberStack.Push(c3);
                             }
                             _operatorStack.Push(op);
                         }
                         else
                         {
                             _operatorStack.Push(op);
                         }
                     }
                 }
                 else if (obj is ComplexNumber)
                 {
                     complexNumber = (ComplexNumber)obj;
                     _complexNumberStack.Push(complexNumber);
                 }

                 if (queue.Count == )
                 {
                     while (_operatorStack.Count != )
                     {
                         topOp = (char)_operatorStack.Pop();
                         ComplexNumber c1 = (ComplexNumber)_complexNumberStack.Pop(); // 符号右边数
                         ComplexNumber c2 = null; // 符号左边数
                         if (_operators.IsTwoNumOperator(topOp))
                         {
                             c2 = (ComplexNumber)_complexNumberStack.Pop();
                         }
                         ComplexNumber c3 = _operators.Compute(topOp, c2, c1);
                         _complexNumberStack.Push(c3);
                     }
                 }
             }

             return (ComplexNumber)_complexNumberStack.Pop();
         }
     }

     // 3+4i解析成Queue包含 3, +, 4i
     public class Parser
     {
         private Operators _operators = new Operators();

         public Queue<object> Parse(string input)
         {
             input = input.Replace(" ", "");
             if (input.StartsWith("-")) input = '' + input;

             char[] arr = input.ToCharArray();
             Queue<char> queueChar = new Queue<char>();
             foreach (char x in arr)
             {
                 queueChar.Enqueue(x);
             }
             Queue<object> queueResult = ParseStringQueue(queueChar);
             return queueResult;
         }

         // 传入字符串队列，返回封装好的队列。
         // ComplexNumber对象或char类型运算符各占用一个结点
         private Queue<object> ParseStringQueue(Queue<char> queue)
         {
             Queue<object> secondQ = new Queue<object>();
             char c;
             StringBuilder sb = null;
             string temp;
             int count = queue.Count;
             bool flag = false; // false表示允许创建新SB对象进行缓存数字字符串
             for (int i = ; i < count; i++)
             {
                 c = queue.Dequeue();
                 if (!_operators.Contains(c))
                 {
                     // 如果扫描到的不是运算符，则将其加入到buffer尾部
                     if (!flag)
                     {
                         flag = true;
                         sb = new StringBuilder();
                     }
                     sb.Append(c);
                 }
                 if (_operators.Contains(c) || queue.Count == )
                 {
                     // 如果扫描到的是运算符，则将缓冲区中的串加入队尾
                     if (sb != null && flag == true)
                     {
                         temp = sb.ToString();
                         try
                         {
                             if (temp.EndsWith("i"))
                             {
                                 if (temp.Length == )
                                 {
                                     secondQ.Enqueue(new ComplexNumber(, ));
                                 }
                                 else
                                 {
                                     // i前有数字则开出数字部分。
                                     temp = temp.Substring(, temp.Length - );
                                     secondQ.Enqueue(new ComplexNumber(, double.Parse(temp)));
                                 }
                             }
                             else
                             {
                                 secondQ.Enqueue(new ComplexNumber(double.Parse(temp), ));
                             }
                             sb = null;
                             flag = false;
                         }
                         catch (Exception e)
                         {
                             UnityEngine.Debug.Log("Error " + e.ToString());
                         }
                     }
                     // 如果是运算符，则最后将运算符放入队。
                     if (_operators.Contains(c))
                     {
                         secondQ.Enqueue(c);
                     }
                 }
             }

             return secondQ;
         }
     }

     // 复数类，提供实数域虚数域，getset方法，加减乘除以及toString()方法
     class ComplexNumber
     {
         private double _realPart; // 实数部分
         private double _imaginPart; // 虚数部分

         public ComplexNumber()
         {
             _realPart = 0.0;
             _imaginPart = 0.0;
         }
         public ComplexNumber(double r, double i)
         {
             _realPart = r;
             _imaginPart = i;
         }
         public ComplexNumber(ComplexNumber c)
         {
             _realPart = c.GetRealPart();
             _imaginPart = c.GetImaginaryPart();
         }

         // get,set方法
         public double GetRealPart()
         {
             return _realPart;
         }
         public double GetImaginaryPart()
         {
             return _imaginPart;
         }
         public void SetRealPart(double d)
         {
             _realPart = d;
         }
         public void SetImaginaryPart(double d)
         {
             _imaginPart = d;
         }

         // 加
         public ComplexNumber ComplexAdd(ComplexNumber c)
         {
             return new ComplexNumber(_realPart + c.GetRealPart(), _imaginPart + c.GetImaginaryPart());
         }
         public ComplexNumber ComplexAdd(double c)
         {
             return new ComplexNumber(_realPart + c, _imaginPart);
         }
         // 减
         public ComplexNumber ComplexMinus(ComplexNumber c)
         {
             return new ComplexNumber(_realPart - c.GetRealPart(), _imaginPart - c.GetImaginaryPart());
         }
         public ComplexNumber ComplexMinus(double c)
         {
             return new ComplexNumber(_realPart - c, _imaginPart);
         }
         // 乘
         public ComplexNumber ComplexMulti(ComplexNumber c)
         {
             return new ComplexNumber(
             _realPart * c.GetRealPart()
             - _imaginPart * c.GetImaginaryPart(),
             _realPart *
             c.GetImaginaryPart()
             + _imaginPart *
             c.GetRealPart());
         }
         public ComplexNumber ComplexMulti(double c)
         {
             return new ComplexNumber(_realPart * c, _imaginPart * c);
         }
         // 除
         public ComplexNumber ComplexDivision(ComplexNumber c)
         {
             return new ComplexNumber((_realPart * c.GetRealPart() + _imaginPart * c.GetImaginaryPart())
                 / (c.GetRealPart() * c.GetRealPart() + c.GetImaginaryPart() * c.GetImaginaryPart())
                 , (_imaginPart * c.GetRealPart() - _realPart * c.GetImaginaryPart())
                 / (c.GetRealPart() * c.GetRealPart() + c.GetImaginaryPart() * c.GetImaginaryPart()));
         }
         public ComplexNumber ComplexDivision(double c)
         {
             return new ComplexNumber(_realPart / c, _imaginPart / c);
         }
         // 幂
         public ComplexNumber ComplexPow(ComplexNumber c)
         {
             int pow;
             if (int.TryParse(c.GetRealPart().ToString(), out pow))
             {
                 ComplexNumber origin = new ComplexNumber(this);
                 ComplexNumber multi = new ComplexNumber(this);
                 for (int i = ; i < pow - ; i++)
                 {
                     origin = origin.ComplexMulti(multi);
                 }
                 return origin;
             }
             else
             {
                 return ComplexPow(c.GetRealPart());
             }
         }
         public ComplexNumber ComplexPow(double c)
         {
             return new ComplexNumber(Math.Pow(_realPart, c), 0.0);
         }
         // 最小值
         public ComplexNumber ComplexMinimum(ComplexNumber c)
         {
             if (_realPart <= c.GetRealPart()) return this;
             return c;
         }
         // 最大值
         public ComplexNumber ComplexMaximum(ComplexNumber c)
         {
             if (_realPart >= c.GetRealPart()) return this;
             return c;
         }
         // 转int
         public ComplexNumber ToFloorInt()
         {
             _realPart = Math.Floor(_realPart);
             return this;
         }

         public override string ToString()
         {
             return "(" + _realPart + " + " + _imaginPart + " i" + ")";
         }
     }

     // 操作符类
     class Operators
     {
         private char[][] _signOperator;

         public Operators()
         {
             // 从上到下，优先级由高到低
             _signOperator = new char[][];
             _signOperator[] = new char[];
             _signOperator[][] = '^';
             _signOperator[][] = 's'; // 最小值
             _signOperator[][] = 'b'; // 最大值
             _signOperator[][] = 'i'; // int值
             _signOperator[] = new char[];
             _signOperator[][] = '*';
             _signOperator[][] = '/';
             _signOperator[] = new char[];
             _signOperator[][] = '+';
             _signOperator[][] = '-';
             _signOperator[] = new char[];
             _signOperator[][] = '(';
             _signOperator[][] = ')';
         }

         // 比较操作符优先级
         public int ComparePriority(char firstSign, char secondSign)
         {
             int priorityF = , priorityS = ;
             for (int i = ; i < _signOperator.Length; i++)
             {
                 foreach (char x in _signOperator[i])
                 {
                     if (firstSign == x)
                     {
                         priorityF = i;
                     }
                     if (secondSign == x)
                     {
                         priorityS = i;
                     }
                 }
             }

             return (priorityF - priorityS);
         }

         // 是否是需要两个参数的操作符
         public bool IsTwoNumOperator(char op)
         {
             if (op == 'i') return false;
             return true;
         }

         public bool Contains(char x)
         {
             if (x == '（' || x == '）')
             {
                 UnityEngine.Debug.LogError(x + "为中文字符，请改为英文字符");
             }

             foreach (char[] arr in _signOperator)
             {
                 foreach (char y in arr)
                 {
                     if (x == y)
                     {
                         return true;
                     }
                 }
             }
             return false;
         }

         public ComplexNumber Compute(char op, ComplexNumber c1, ComplexNumber c2)
         {
             ComplexNumber result = null;
             switch (op)
             {
                 case '+': result = c1.ComplexAdd(c2); break;
                 case '-': result = c1.ComplexMinus(c2); break;
                 case '*': result = c1.ComplexMulti(c2); break;
                 case '/': result = c1.ComplexDivision(c2); break;
                 case '^': result = c1.ComplexPow(c2); break;
                 case 's': result = c1.ComplexMinimum(c2); break;
                 case 'b': result = c1.ComplexMaximum(c2); break;
                 case 'i': result = c2.ToFloorInt(); break;
             }
             return result;
         }
     }
 }

仓促上传待整理。。。