C#利用栈实现加减乘除运算(2)

当前位置:
首页 > Python基础教程 >

C#利用栈实现加减乘除运算(2)
Don_Yao整合修复一些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;

    }

  }

}
栏目列表