C#利用后缀表达式解析计算字符串公式

public enum BracketEnum { /// 
 /// Undefined /// 
 Undefined = 0, /// 
 /// 左括号 /// 
 Open, /// 
 /// 右括号 /// 
 Close }

public enum NodeTypeEnum { /// 
 /// Null /// 
 Null = 0, /// 
 /// 操作数 /// 
 Number, /// 
 /// 操作符 /// 
 Operator, /// 
 /// 括号 /// 
 Bracket, }

public enum OperatorEnum { /// 
 /// Undefined /// 
 Undefined = 0, /// 
 /// + /// 
 Plus, /// 
 /// - /// 
 Minus, /// 
 /// * /// 
 Multiply, /// 
 /// / /// 
 Divide, /// 
 /// ^ /// 
 Power, }

public class BaseNode { public BaseNode(NodeTypeEnum nodeType) { NodeType = nodeType; } /// 
 /// 节点类型 /// 
 public NodeTypeEnum NodeType { get; set; } }

public class BracketNode : BaseNode { /// 
 /// 括号值 /// 
 public BracketEnum Bracket { get; } /// 
 /// 公式括号节点 /// 
 public BracketNode(BracketEnum bracket) : base(NodeTypeEnum.Bracket) { Bracket = bracket; } }

public class NumberNode : BaseNode { /// 
 /// 数字值 /// 
 public double Number { get; } public NumberNode(double number) : base(NodeTypeEnum.Number) { Number = number; } }

public class OperatorNode : BaseNode { /// 
 /// 操作字符串枚举 /// 
 public OperatorEnum OperatorKey { get; } /// 
 /// 优先级 /// 
 public int Priority { get; } public OperatorNode(OperatorEnum operatorKey) : base(NodeTypeEnum.Operator) { OperatorKey = operatorKey; Priority = GetPriority(); } private int GetPriority() { var priority = OperatorKey switch { OperatorEnum.Power => 6, OperatorEnum.Multiply => 5, OperatorEnum.Divide => 5, OperatorEnum.Plus => 4, OperatorEnum.Minus => 4, _ => 0 }; return priority; } }

public static class BracketReader { /// 
 /// 左右括号字符 /// 
 private const char OPEN_BRACKET_CHAR = '('; private const char CLOSE_BRACKET_CHAR = ')'; /// 
 /// 尝试获取左括号 /// 
 /// 公式节点信息 /// 公式字符 /// 公式读取的下标 ///  public static bool TryProceedOpenBracket(List nodes, ReadOnlySpan formula, ref int index) { if (formula[index].Equals(OPEN_BRACKET_CHAR)) { nodes.Add(new BracketNode(BracketEnum.Open)); return true; } return false; } /// 
 /// 尝试获取右括号 /// 
 /// 公式节点信息 /// 公式字符 /// 公式读取的下标 ///  public static bool TryProceedCloseBracket(List nodes, ReadOnlySpan formula, ref int index) { if (formula[index].Equals(CLOSE_BRACKET_CHAR)) { nodes.Add(new BracketNode(BracketEnum.Close)); return true; } return false; } }

public static class NumberReader { /// 
 /// 尝试读取数字 /// 
 public static bool TryProceedNumber(List nodes, ReadOnlySpan formula, ref int index) { double value = 0; var isTry = false;//是否转换成功 var isNegative = formula[index] == '-';//是否是负数 var localIndex = isNegative ? index + 1 : index; //循环判断数字 for (int i = localIndex; i  /// 判断是不是数字或者. ///  /// 字符 ///  private static bool IsFloatingNumber(char ch) { //是不是十进制数 var isDigit = char.IsDigit(ch); return isDigit || ch == '.'; } }

/// 
 /// 操作符解读 /// 
 public static class OperatorReader { private static readonly string[] _operators = new[] { "+", "-", "*", "/", "^" }; /// 
 /// 尝试获取操作符 /// 
 public static bool TryProceedOperator(List nodes, ReadOnlySpan formula, ref int index) { if (_operators.Contains(formula[index].ToString())) { nodes.Add(new OperatorNode(GetOperatorKey(formula[index].ToString()))); return true; } return false; } /// 
 /// 获取对应枚举 /// 
 ///  ///  private static OperatorEnum GetOperatorKey(string name) { return name switch { "+" => OperatorEnum.Plus, "-" => OperatorEnum.Minus, "*" => OperatorEnum.Multiply, "/" => OperatorEnum.Divide, "^" => OperatorEnum.Power, _ => OperatorEnum.Undefined }; } }

/// 
 /// 解析公式为节点 /// 
 /// 公式字符串 ///  public static List AnalysisFormulaToNodes(string formula) { var nodes = new List(); for(var index = 0;index

/// 
 /// 转为后缀表达式 /// 
 ///  ///  public static List GetRPN(List nodes) { var rpnNodes = new List(); var tempNodes = new Stack(); foreach(var t in nodes) { //1、如果是操作数直接入栈 if(t.NodeType == NodeTypeEnum.Number) { rpnNodes.Add(t); continue; } //2、若取出的字符是运算符,则循环比较S1栈顶的运算符（包括左括号）优先级，如果栈顶的运算符优先级大于等于该运算符的优先级，则S1栈顶运算符弹出加入到S2中直至不满足条件为止，最后将该运算符送入S1中。 if (t.NodeType == NodeTypeEnum.Operator) { while (tempNodes.Count > 0) { var peekOperatorNode = tempNodes.Peek() as OperatorNode; if (peekOperatorNode != null && peekOperatorNode.Priority >= (t as OperatorNode).Priority) { rpnNodes.Add(tempNodes.Pop()); } else { break; } } tempNodes.Push(t); continue; } //3、若取出的字符是“（”，则直接送入S1栈顶 if(t.NodeType == NodeTypeEnum.Bracket) { if((t as BracketNode).Bracket == BracketEnum.Open) { tempNodes.Push(t); continue; } } //4、若取出的字符是“）”，则将距离S1栈栈顶最近的“（”之间的运算符，逐个出栈，依次送入S2栈，此时抛弃“（”。 if (t.NodeType == NodeTypeEnum.Bracket) { if ((t as BracketNode).Bracket == BracketEnum.Close) { while (tempNodes.Count > 0) { var peekBracketNode = tempNodes.Peek() as BracketNode; if (tempNodes.Peek().NodeType == NodeTypeEnum.Bracket && peekBracketNode != null && peekBracketNode.Bracket == BracketEnum.Open) { break; } else { rpnNodes.Add(tempNodes.Pop()); } } tempNodes.Pop(); continue; } } //5、重复上述步骤 } if(tempNodes.Count > 0) { rpnNodes.Add(tempNodes.Pop()); } return rpnNodes; }

/// 
 /// 计算后缀表达式 /// 
 ///  ///  public static double CalculationRPN(List nodes) { double result = 0; Stack stack = new Stack(); foreach(var t in nodes) { if(t.NodeType == NodeTypeEnum.Number) { //操作数直接入栈 stack.Push(t); } else if(t.NodeType == NodeTypeEnum.Operator) { //操作符弹出栈顶两个进行计算 var a = stack.Pop(); var b = stack.Pop(); var operate = t as OperatorNode; var value = operate.OperatorKey switch { // 数学操作符 OperatorEnum.Multiply => OperatorService.Multiply(a, b), OperatorEnum.Divide => OperatorService.Divide(a, b), OperatorEnum.Plus => OperatorService.Plus(a, b), OperatorEnum.Minus => OperatorService.Minus(a, b), OperatorEnum.Power => OperatorService.Power(a, b), }; stack.Push(new NumberNode(value)); } } result = (stack.Pop() as NumberNode).Number; return result; }

/// 
 /// 操作符服务 /// 
 public static class OperatorService { #region Math public static double Multiply(in BaseNode a, in BaseNode b) { var (result, _a, _b) = IsNumber(a, b); if (result) { return _a * _b; } return default; } public static double Divide(in BaseNode a, in BaseNode b) { var (result, _a, _b) = IsNumber(a, b); if (result) { return _a / _b; } return default; } public static double Plus(in BaseNode a, in BaseNode b) { var (result, _a, _b) = IsNumber(a, b); if (result) { return _a + _b; } return default; } public static double Minus(in BaseNode a, in BaseNode b) { var (result, _a, _b) = IsNumber(a, b); if (result) { return _a - _b; } return default; } public static double Power(in BaseNode a, in BaseNode b) { var (result, _a, _b) = IsNumber(a, b); if (result) { return Math.Pow(_a, _b); } return default; } /// 
 /// 判断是不是数字类型，并返回数字 /// 
 ///  ///  private static (bool,double,double) IsNumber(BaseNode a, in BaseNode b) { if(a.NodeType == NodeTypeEnum.Number && b.NodeType == NodeTypeEnum.Number) { var _a = a as NumberNode; var _b = b as NumberNode; return (true, _a.Number, _b.Number); } return (false, default, default); } #endregion }

/// 
 /// 计算 /// 
 /// 公式字符串 ///  public static double Calculation(string formula) { //1、获取公式节点 var nodes = AnalysisFormulaToNodes(formula); //2、转后缀表达式 var rpnNodes = GetRPN(nodes); //3、计算对后缀表达式求值 var result = CalculationRPN(rpnNodes); return result; }