成都创新互联网站制作重庆分公司

怎么在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://cxhlcq.com/article/gjiii.html
        
    



    
其他资讯

    




    

        

            
        

        

            
全国免费咨询:

            400-028-6601
            
业务咨询：028-86922220 / 13518219792

            
节假值班：18980820575 / 13518219792

            
联系地址：成都市太升南路288号锦天国际A幢1002号

        

    

    

        

            
Copyright © 成都创新互联科技有限公司重庆分公司  渝ICP备2021005571号

            
        

    

    

        

            友情链接:：
            成都网站建设
            重庆网站建设
            四川网站建设
            重庆建设网站
            移动服务器托管
            成都服务器托管
            云服务器
            广告设计制作
            重庆网页设计
            重庆做网站
            重庆网站制作
            重庆网站建设
            重庆网站公司
            渝中网站制作
            重庆网站设计
        

    





    




    

        

            
                
                
在线咨询

            
        

    

    

        
微信咨询

        

    

    

        
电话咨询

        

            
028-86922220（工作日）

            
18980820575（7×24）

        

    

    

        

            
                
提交需求

            
        

    

    

        

            
                
返回顶部