怎么在C#中利用栈实现加减乘除运算-创新互联

这期内容当中小编将会给大家带来有关怎么在C#中利用栈实现加减乘除运算,文章内容丰富且以专业的角度为大家分析和叙述,阅读完这篇文章希望大家可以有所收获。

站在用户的角度思考问题,与客户深入沟通,找到博罗网站设计与博罗网站推广的解决方案,凭借多年的经验,让设计与互联网技术结合,创造个性化、用户体验好的作品,建站类型包括:成都做网站、成都网站建设、企业官网、英文网站、手机端网站、网站推广、域名与空间、虚拟空间、企业邮箱。业务覆盖博罗地区。

   类Parser   的parse方法,比如给一个“3+4i”的字符串,返回给你一个3个结点的队,队列第一个元素是一个ComplexNumber对象,实数域为3,队列的第二个元素是“+”号,队列第三个元素是一个ComplexNumber对象,实数域为0,虚数域为4。

    类Operators    用于测试字符是否是运算符,用来进行控制运算,比较运算符优先级....

    类Handler   给一个字符串,他帮你处理,返回给你一个结果。其实就是调一下Parser类的方法去解析一下字符串,然后算一下结果,然后返回结果。

 类ComplexNumber,就是复数类啊,不用说了,提供实数域虚数域,getset方法,加减乘除以及toString()方法

using System;
using System.Collections;
using System.Text;
namespace MySpace{
	class Parser{
		public static Queue Parse(string input){
			char[] arr = input.ToCharArray();
			Queue queue = new Queue();
			foreach(char x in arr){
				queue.Enqueue(x);
			}
			queue = ParseStringQueue(queue);
			return queue;
		}
		
		//传入字符串队列,返回封装好的队列。
		//ComplexNumber对象或char类型运算符各占用一个结点
		private static Queue ParseStringQueue(Queue queue){
			Queue secondQ = new Queue();
			char c;
			StringBuilder sb = null;
			string temp;
			int count = queue.Count;
			bool flag = false; //false表示允许创建新SB对象进行缓存数字字符串
			for(int i=0;i

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 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 Parse(string input)
    {
      input = input.Replace(" ", "");
      if (input.StartsWith("-")) input = '0' + input;

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

    // 传入字符串队列,返回封装好的队列。
    // ComplexNumber对象或char类型运算符各占用一个结点
    private Queue ParseStringQueue(Queue queue)
    {
      Queue secondQ = new Queue();
      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;
    }
  }
}

上述就是小编为大家分享的怎么在C#中利用栈实现加减乘除运算了,如果刚好有类似的疑惑,不妨参照上述分析进行理解。如果想知道更多相关知识,欢迎关注创新互联成都网站设计公司行业资讯频道。

另外有需要云服务器可以了解下创新互联scvps.cn,海内外云服务器15元起步,三天无理由+7*72小时售后在线,公司持有idc许可证,提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案,具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势,专为企业上云打造定制,能够满足用户丰富、多元化的应用场景需求。


本文标题:怎么在C#中利用栈实现加减乘除运算-创新互联
当前地址:http://scyanting.com/article/gjiii.html