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 = 0; i < count; i++)
            {
                object obj = queue.Dequeue();
                if (obj is char)
                {
                    op = (char)obj;
                    if (_operatorStack.Count == 0)
                    {
                        _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) <= 0)
                        {
                            // 若即将压入的运算符不是括号，则比较栈顶运算符和即将压入的运算符的优先级
                            // 如果栈顶优先级高，则将栈顶运算符取出运算，直到栈顶优先级不大于其。
                            while (_operatorStack.Count != 0 && _operators.ComparePriority((char)_operatorStack.Peek(), op) <= 0)
                            {
                                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 == 0)
                {
                    while (_operatorStack.Count != 0)
                    {
                        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 = '0' + 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 = 0; 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 == 0)
                {
                    // 如果扫描到的是运算符，则将缓冲区中的串加入队尾
                    if (sb != null && flag == true)
                    {
                        temp = sb.ToString();
                        try
                        {
                            if (temp.EndsWith("i"))
                            {
                                if (temp.Length == 1)
                                {
                                    secondQ.Enqueue(new ComplexNumber(0, 1));
                                }
                                else
                                {
                                    // i前有数字则开出数字部分。
                                    temp = temp.Substring(0, temp.Length - 1);
                                    secondQ.Enqueue(new ComplexNumber(0, double.Parse(temp)));
                                }
                            }
                            else
                            {
                                secondQ.Enqueue(new ComplexNumber(double.Parse(temp), 0));
                            }
                            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 = 0; i < pow - 1; 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[4][];
            _signOperator[0] = new char[4];
            _signOperator[0][0] = '^';
            _signOperator[0][1] = 's'; // 最小值
            _signOperator[0][2] = 'b'; // 最大值
            _signOperator[0][3] = 'i'; // int值
            _signOperator[1] = new char[2];
            _signOperator[1][0] = '*';
            _signOperator[1][1] = '/';
            _signOperator[2] = new char[2];
            _signOperator[2][0] = '+';
            _signOperator[2][1] = '-';
            _signOperator[3] = new char[2];
            _signOperator[3][0] = '(';
            _signOperator[3][1] = ')';
        }

        // 比较操作符优先级
        public int ComparePriority(char firstSign, char secondSign)
        {
            int priorityF = 0, priorityS = 0;
            for (int i = 0; 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;
        }
    }
}

仓促上传待整理。。。