C#解析字符串公式

  /// <summary>
        /// 中缀表达式到逆波兰表达式的转换及求值
        /// </summary>
        public class RpnExpression
        {
 
          #region  定义属性
            int Top = -1;
            #endregion
 
          /// <summary>
        /// 检查中缀表达式是否合法
        /// </summary>
        /// <param name="exp"></param>
        /// <returns></returns>
          public  bool IsRight(string exp)
            {
                string pMatch = @"\([^\(^\)]+\)";//匹配最“内”层括号及表达式
                string numberMatch = @"\d+(\.\d+)?";//匹配数字
                string exMatch = @"^0([-+*/]0)*$";//匹配无括号的、用0替换所有的数字后的表达式
 
                exp = Regex.Replace(exp, numberMatch, "0");//为简化检测，用0替换所有的数字
                while (Regex.IsMatch(exp, pMatch))
                {
                    foreach (Match match in Regex.Matches(exp, pMatch))
                    {
                        string tmp = match.Value;
                        tmp = tmp.Substring(1, tmp.Length - 2);//去掉 "("和 ")"
                        if (!Regex.IsMatch(tmp, exMatch)) return false;
                    }
                    exp = Regex.Replace(exp, pMatch, "0");//将最内层的括号及括号内表达式直接用一个0代替
                }
 
                return Regex.IsMatch(exp, exMatch);
            }
 
          #region 生成逆波兰表达式
        /// <summary>
        /// 获取逆波兰表达式
        /// </summary>
        /// <param name="exp"></param>
        /// <returns></returns>
        public  string RpnExp(string exp)
        {
            string S = ""; //后缀
            char[] Operators = new char[exp.Length];
 
            for (int i = 0; i < exp.Length; i++)
            {
                char C = exp[i];
                switch (C)
                {
                    case ' ': //忽略空格
                        break;
                    case '+': //操作符
                    case '-':
                        while (Top >= 0) //栈不为空时
                        {
                            char c = Operators[Top--]; //pop Operator
                            if (c == '(')
                            {
                                Operators[++Top] = c; //push Operator
                                break;
                            }
                            else
                            {
                                S = S + c;
                            }
                        }
                        Operators[++Top] = C; //push Operator
                        S += " ";
                        break;
                    case '*': //忽略空格
                    case '/':
                        while (Top >= 0) //栈不为空时
                        {
                            char c = Operators[Top--]; //pop Operator
                            if (c == '(')
                            {
                                Operators[++Top] = c; //push Operator
                                break;
                            }
                            else
                            {
                                if (c == '+' || c == '-')
                                {
                                    Operators[++Top] = c; //push Operator
                                    break;
                                }
                                else
                                {
                                    S = S + c;
                                }
                            }
                        }
                        Operators[++Top] = C; //push Operator
                        S += " ";
                        break;
                    case '(':
                        Operators[++Top] = C;
                        S += " ";
                        break;
                    case ')':
                        while (Top >= 0) //栈不为空时
                        {
                            char c = Operators[Top--]; //pop Operator
                            if (c == '(')
                            {
                                break;
                            }
                            else
                            {
                                S = S + c;
                            }
                        }
                        S += " ";
                        break;
                    default:
                        S = S + C;
                        break;
 
                }
            }
            while (Top >= 0)
            {
                S = S + Operators[Top--]; //pop Operator
            }
            return S;
        }
 
        #endregion
 
          #region 取逆波兰表达式的值
        /// <summary>
        /// 获取逆波兰表达式的值
        /// </summary>
        /// <param name="rpnExp"></param>
        /// <returns></returns>
        public  double GetValueByRpn(string rpnExp)
        {
            //后缀表达式计算
            double[] Operands = new double[rpnExp.Length];
            double x, y, v;
            Top = -1;
            string Operand = "";
            for (int i = 0; i < rpnExp.Length; i++)
            {
                char c = rpnExp[i];
                if ((c >= '0' && c <= '9') || c == '.')
                {
                    Operand += c;
                }
 
                if ((c == ' ' || i == rpnExp.Length - 1) && Operand != "") //Update
                {
                    Operands[++Top] = System.Convert.ToDouble(Operand); //push Operands
                    Operand = "";
                }
 
                if (c == '+' || c == '-' || c == '*' || c == '/')
                {
                    if ((Operand != ""))
                    {
                        Operands[++Top] = System.Convert.ToDouble(Operand); //push Operands
                        Operand = "";
                    }
                    y = Operands[Top--]; //pop 双目运算符的第二操作数 (后进先出)注意操作数顺序对除法的影响
                    x = Operands[Top--]; //pop 双目运算符的第一操作数
                    switch (c)
                    {
                        case '+':
                            v = x + y;
                            break;
                        case '-':
                            v = x - y;
                            break;
                        case '*':
                            v = x * y;
                            break;
                        case '/':
                            v = x / y; // 第一操作数 / 第二操作数 注意操作数顺序对除法的影响
                            break;
                        default:
                            v = 0;
                            break;
                    }
                    Operands[++Top] = v; //push 中间结果再次入栈
                }
            }
            v = Operands[Top--]; //pop 最终结果
            return v;
        }
      #endregion
        }

1.先说明下这个实现算法--逆波兰表达式

表达式一般由操作数(Operand)、运算符(Operator)组成，例如算术表达式中，通常把运算符放在两个操作数的中间，

这称为中缀表达式(Infix Expression)，如A+B。

波兰数学家Jan Lukasiewicz提出了另一种数学表示法，它有两种表示形式：

把运算符写在操作数之前，称为波兰表达式(Polish Expression)或前缀表达式(Prefix Expression)，如+AB；

把运算符写在操作数之后，称为逆波兰表达式(Reverse Polish Expression)或后缀表达式(Suffix Expression)，如AB+；

其中，逆波兰表达式在编译技术中有着普遍的应用。

算法：

一、 将中缀表达式转换成后缀表达式算法：

1、从左至右扫描一中缀表达式。

2、若读取的是操作数，则判断该操作数的类型，并将该操作数存入操作数堆栈

3、若读取的是运算符

(1) 该运算符为左括号"("，则直接存入运算符堆栈。

(2) 该运算符为右括号")"，则输出运算符堆栈中的运算符到操作数堆栈，直到遇到左括号为止。

(3) 该运算符为非括号运算符：

(a) 若运算符堆栈栈顶的运算符为括号，则直接存入运算符堆栈。

(b) 若比运算符堆栈栈顶的运算符优先级高或相等，则直接存入运算符堆栈。

(c) 若比运算符堆栈栈顶的运算符优先级低，则输出栈顶运算符到操作数堆栈，并将当前运算符压入运算符堆栈。

4、当表达式读取完成后运算符堆栈中尚有运算符时，则依序取出运算符到操作数堆栈，直到运算符堆栈为空

示例：

（1.2+3.5）*2/4 =>1.2 3.5+ 2* 4/

下面给出实现代码：