问题：实现一个解析器，可以将文本解析成表达式树；例如："-3 + 4 * (2 / -log( 1 - 5 ))"
表达式数据结构：操作符 + – × / ()，常数，等等，都应被定义为一种类。特别说明，将括号定义为一种表达式是很有必要的。对于负号的处理，可以在表达式类中加入一个成员变量做标记；
解析器：上面的树状结构是结果，获得这个树，就需要对字符进行解析，来创建树，基本逻辑如下。
1，从左到右读字符串，如果是空格，忽略；如果是常数，创建一个常数表达式；如果是括号，将括号里的字符串提取出来，递归，括号里的字符串会被解析为一个表达式；如果是函数，将函数括号里的字符串提取出来，递归，得到一个表达式作为函数表达式的操作数；如果是操作符，提取操作符，按字符串保存；最终结果，得到一个表达式对象和字符串的混合数组；
2，处理负号，将负号并入表达式里；
3，按操作符操作优先级建立操作符表达式；
代码：示例代码，不完整。
表达式类
using System; using System.Collections.Generic; using System.Linq; using System.Numerics; using System.Text; namespace Program { public enum EquResultDataType { rtConst, rtComplexArry } public class EquationException : Exception { public EquationException(string msg) : base(msg) { } public EquationException(string msg, Exception innerExp) : base(msg, innerExp) { } } public abstract class Equation { virtual public object Evaluate() { throw new NotImplementedException(); } public EquResultDataType ResultDataType { get; protected set; } // if the equation start with a ' - ' private double _sign = 1.0; protected double Sign { get { return _sign; } } virtual public void MultiplyMinusOne() { _sign *= -1.0; } virtual public string ToEquationText() { throw new NotImplementedException(); } } public class BinaryEquation : Equation { public Equation LeftOperand { get; set; } public Equation RightOperand { get; set; } } public class UnaryEquaton : Equation { public Equation Operand { get; set; } } public class EquAddition : BinaryEquation { public override object Evaluate() { object leftResult = LeftOperand.Evaluate(); object rightResult = RightOperand.Evaluate(); if (LeftOperand.ResultDataType == EquResultDataType.rtComplexArry && RightOperand.ResultDataType == EquResultDataType.rtComplexArry) { Complex[] leftData = leftResult as Complex[]; Complex[] rightData = rightResult as Complex[]; if (leftData.Length != rightData.Length) throw new EquationException(string.Format("{0}, {1}: data length are not equal.", LeftOperand.ToEquationText(), RightOperand.ToEquationText())); else { Complex[] result = new Complex[leftData.Length]; for (int i = 0; i < leftData.Length; ++i) { result[i] = leftData[i] + rightData[i]; } if (Sign < 0) { for (int i = 0; i < result.Length; ++i) result[i] *= -1.0; } return result; } } else if (LeftOperand.ResultDataType == EquResultDataType.rtComplexArry && RightOperand.ResultDataType == EquResultDataType.rtConst) { Complex[] leftData = leftResult as Complex[]; double rightData = (double)rightResult; Complex[] result = new Complex[leftData.Length]; for (int i = 0; i < leftData.Length; ++i) { result[i] = leftData[i] + rightData; } if (Sign < 0) { for (int i = 0; i < result.Length; ++i) result[i] *= -1.0; } return result; } else if (LeftOperand.ResultDataType == EquResultDataType.rtConst && RightOperand.ResultDataType == EquResultDataType.rtComplexArry) { double leftData = (double)leftResult; Complex[] rightData = rightResult as Complex[]; Complex[] result = new Complex[rightData.Length]; for (int i = 0; i < rightData.Length; ++i) { result[i] = leftData + rightData[i]; } if (Sign < 0) { for (int i = 0; i < result.Length; ++i) result[i] *= -1.0; } return result; } else if (LeftOperand.ResultDataType == EquResultDataType.rtConst && RightOperand.ResultDataType == EquResultDataType.rtConst) { double leftData = (double)leftResult; double rightData = (double)rightResult; double result = leftData + rightData; if (Sign < 0) result *= -1.0; return result; } else { throw new EquationException("Child equation evaluate error!"); } } public override string ToEquationText() { return LeftOperand.ToEquationText() + " + " + RightOperand.ToEquationText(); } } public class EquSubtraction : BinaryEquation { public override object Evaluate() { throw new NotImplementedException(); } public override string ToEquationText() { return LeftOperand.ToEquationText() + " - " + RightOperand.ToEquationText(); } } public class EquMultiplication : BinaryEquation { public override object Evaluate() { throw new NotImplementedException(); } public override string ToEquationText() { return LeftOperand.ToEquationText() + " * " + RightOperand.ToEquationText(); } } public class EquDivision : BinaryEquation { public override object Evaluate() { throw new NotImplementedException(); } public override string ToEquationText() { return LeftOperand.ToEquationText() + " / " + RightOperand.ToEquationText(); } } public class EquParenthesis : UnaryEquaton { public override object Evaluate() { if (Sign < 0) Operand.MultiplyMinusOne(); object result = Operand.Evaluate(); return result; } public override string ToEquationText() { string txt = "( " + Operand.ToEquationText() + " )"; if (Sign < 0) txt = "-" + txt; return txt; } } public class EquConstant : UnaryEquaton { double _const = 0.0; public EquConstant(double c) { _const = c; } public override void MultiplyMinusOne() { _const *= -1.0; } public override object Evaluate() { return _const; } public override string ToEquationText() { return _const.ToString(); } } public class EquFunction : UnaryEquaton { public override object Evaluate() { object val = Operand.Evaluate(); switch (Operand.ResultDataType) { case EquResultDataType.rtConst: { double d = (double)val; ResultDataType = EquResultDataType.rtConst; double result = Math.Log(d); if (Sign < 0) result *= -1.0; return result; } case EquResultDataType.rtComplexArry: { Complex[] arr = val as Complex[]; for (int i = 0; i < arr.Length; ++i) arr[i] = Complex.Log(arr[i]); ResultDataType = EquResultDataType.rtComplexArry; if (Sign < 0) { for (int i = 0; i < arr.Length; ++i) arr[i] *= -1.0; } return arr; } default: throw new EquationException("Child equation evaluate error!"); } } public override string ToEquationText() { string txt = "Log(" + Operand.ToEquationText() + ")"; if (Sign < 0) txt = "-" + txt; return txt; } } }
解析器
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Diagnostics; using System.Text.RegularExpressions; namespace Program { public class EquationBuilder { List<object> tokens = new List<object>(); protected string TokenizeParenthesis(string txt, ref int startpos) { string tok = txt.Substring(startpos, 1); while (tok == " ") // remove leading space { ++startpos; tok = txt.Substring(startpos, 1); } int pos0 = startpos; // position when start int cntLeftParenthesis = 0; if (tok == "(") { ++cntLeftParenthesis; ++startpos; } else { Debug.Assert(txt.StartsWith("(")); return string.Empty; } while (cntLeftParenthesis > 0) { if (startpos >= txt.Length) throw new EquationException("Parenthesis mismatch"); tok = txt.Substring(startpos, 1); ++startpos; if (tok == "(") { ++cntLeftParenthesis; } else if (tok == ")") { --cntLeftParenthesis; } } int pos1 = startpos; // position when finish string str = txt.Substring(pos0, pos1 - pos0); Debug.Assert(!string.IsNullOrWhiteSpace(str)); Debug.Assert(str.StartsWith("(") && str.EndsWith(")")); str = str.Substring(1, str.Length - 2); // remove '(', ')' return str; } protected object Tokenize(string txt, ref int startpos) { // () + - * / string tok = txt.Substring(startpos, 1); switch (tok) { case " ": { ++startpos; return null; } case "(": { string str = TokenizeParenthesis(txt, ref startpos); EquationBuilder bd = new EquationBuilder(); // recursive Equation operand = bd.Build(str); EquParenthesis equ = new EquParenthesis() { Operand = operand }; return equ; } case "+": case "-": case "*": case "/": { ++startpos; return tok; } } // functions if (startpos + 3 < txt.Length) { tok = txt.Substring(startpos, 3); if (tok.ToUpper() == "LOG") { startpos += 3; String str = TokenizeParenthesis(txt, ref startpos); if (string.IsNullOrWhiteSpace(str)) throw new EquationException(string.Format("Invalide argurment of function '{0}'", tok)); EquationBuilder bd = new EquationBuilder(); // recursive Equation operand = bd.Build(str); EquFunction equ = new EquFunction() { Operand = operand }; return equ; } } // dut data // ... // constants Regex reg = new Regex(@"^(\d*\.\d+|\d+|\d+\.\d*)"); tok = txt.Substring(startpos, txt.Length - startpos); Match mt = reg.Match(tok); if (mt.Success) { tok = mt.Value; startpos += tok.Length; EquConstant equ = new EquConstant(Convert.ToDouble(tok)); return equ; } string err = string.Format("Unrecognized string '{0}'", txt.Substring(startpos, txt.Length - startpos)); throw new EquationException(err); } static int OperatorPrecedence(string op1, string op2) { switch (op1) { case "+": case "-": { switch (op2) { case "+": case "-": return 0; case "*": case "/": return -1; default: throw new EquationException("Unrecognized operator " + op2); } } case "*": case "/": { switch (op2) { case "+": case "-": return 1; case "*": case "/": return 0; default: throw new EquationException("Unrecognized operator " + op2); } } default: throw new EquationException("Unrecognized operator " + op1); } } static Equation Build(Equation left, Equation right, string op) { switch (op) { case "+": return new EquAddition() { LeftOperand = left, RightOperand = right }; case "-": return new EquSubtraction() { LeftOperand = left, RightOperand = right }; case "*": return new EquMultiplication() { LeftOperand = left, RightOperand = right }; case "/": return new EquDivision() { LeftOperand = left, RightOperand = right }; default: throw new EquationException("Unrecognized operator " + op); } } public Equation Build(string txt) { // clear leading space txt = txt.Trim(); // if the text is "( ... )" if (txt.StartsWith("(") && txt.EndsWith(")")) { txt = txt.Substring(1, txt.Length - 2); Debug.Assert(false); } // example: txt = "-3 + 4 * (2 / -log( 1 - 5 ))" // tokenize it to top level segments int pos = 0; while (pos < txt.Length) { object obj = Tokenize(txt, ref pos); if (obj != null) tokens.Add(obj); } // example: tokens should be {-, 3, +, 4, equ} // bring '-' into equation if there is one for (int i = tokens.Count - 1; i >= 0; --i) { object o = tokens[i]; if (o is Equation) { if (i >= 2 && (tokens[i - 1] is string) && (tokens[i - 2] is string)) { string str2 = tokens[i - 2] as string; string str1 = tokens[i - 1] as string; Equation equ = o as Equation; if (str1 == "-") { equ.MultiplyMinusOne(); tokens.RemoveAt(i - 1); } else { string err = string.Format("Lack of operand between operators '{0}{1}'", str2, str1); throw new EquationException(err); } } else if (i == 1 && (tokens[i - 1] is string)) { string str1 = tokens[0] as string; Equation equ = o as Equation; if (str1 == "-") { equ.MultiplyMinusOne(); tokens.RemoveAt(i - 1); } else { string err = string.Format("Lack of operand before '{0}{1}'", str1, equ.ToEquationText()); throw new EquationException(err); } } } } // example: tokens now should be {-3, +, 4, equ(modified in inner recursive)} // check, now the tokens should be like {equ, operator, equ, operator, ..., operator, equ} bool beEqu = true; for (int i = 0; i < tokens.Count; ++i) { object o = tokens[i]; if (beEqu != (tokens[i] is Equation)) { string str1 = string.Empty; if (i - 1 >= 0) { if (tokens[i - 1] is Equation) str1 = (tokens[i - 1] as Equation).ToEquationText(); else str1 = tokens[i - 1] as string; } string str = string.Empty; if (tokens[i] is Equation) str = (tokens[i] as Equation).ToEquationText(); else str = tokens[i] as string; string str2 = string.Empty; if (i + 1 < tokens.Count) { if (tokens[i + 1] is Equation) str2 = (tokens[i + 1] as Equation).ToEquationText(); else str2 = tokens[i + 1] as string; } string err = string.Format("Lack of operands/operators '{0}{1}{2}'", str1, str, str2); throw new EquationException(err); } beEqu = !beEqu; } if (tokens[tokens.Count - 1] is string) { throw new EquationException("Lack of operand at the end"); } // build the tree according precedence Stack<string> opStack = new Stack<string>(); Stack<Equation> eqStack = new Stack<Equation>(); for (int i = 0; i < tokens.Count; ++i) { object o = tokens[i]; if (o is Equation) { eqStack.Push(o as Equation); } else if (o is string) { string op = o as string; if (opStack.Count == 0) { opStack.Push(op); } else { // if new add operator is less precedence, build previous first while (true) { string op0 = opStack.Peek(); if (OperatorPrecedence(op, op0) < 0) { Equation right = eqStack.Pop(); Equation left = eqStack.Pop(); Debug.Assert(left != null && right != null); op0 = opStack.Pop(); Equation equ = Build(left, right, op0); eqStack.Push(equ); if (opStack.Count == 0) break; } else { break; } } // then, still push the new operator in opStack.Push(op); } } } while (opStack.Count > 0) { Equation right = eqStack.Pop(); Equation left = eqStack.Pop(); string op = opStack.Pop(); Equation equ = Build(left, right, op); eqStack.Push(equ); } Debug.Assert(eqStack.Count == 1); Equation equResult = eqStack.Pop(); return equResult; } } }
例子：
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace Program { class Program { static void Main(string[] args) { string txt = "-3 + 4 * (2 / -log( 1 - 5 ))"; //string txt = "3 + 4"; EquationBuilder bd = new EquationBuilder(); Equation equ = bd.Build(txt); Console.WriteLine(equ.ToEquationText()); Console.Read(); } } }
