一种表达式求值的简便算法

假如你有一个表示表达式的字符串,例如:string s="32.76+4*(37+2/35.6)";

怎么求出它的值?好象有点困难吧,现在可以象这样计算它的值了:

double x=s.ToValue();

函数:ToValue()就是本文要说的一种表达式求值的简便算法.

先大体上介绍一下算法

算法分三个层次,每一层次用一个函数来实现,这三个层次分别是:

一、处理括号

找出优先级最高的括号，调用第二个层次的函数计算*和/运算，再调用第三层次的函数做+和 -运算

二、处理 * 和 /运算

经过第一层次的处理,表达式已无括号,这个层次集中处理表达式中的 * 和 / 运算.

三、处理 + 和 - 运算

经过前二个层的处理，表达式已无括号，无 * 和 /运算,本层专门计算加减法.

最后检查一下最终结果,看是否存在异常.正常就返回结果，这个函数就是前面提到的ToValue()

这个函数作为 string类型的扩展函数提供,使用更便捷.

不多说了,上代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using liudazhen;

namespace ConsoleApplication1
{
    class Program
    {
        /// <summary>
        /// 调用示例,示范表达式求值方法的调用方法.注意别忘记导入名空间:liudazhen;
        /// </summary>
        static void Main(string[] args)
        {
            string s = " 12.456 - ( 3.78 - 5.781*3.73 +2.7 * (-5))/3.78 ";
            try
            {
                double v = s.ToValue();
                Console.WriteLine(v.ToString());
                Console.ReadKey();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                Console.ReadKey();
            }

        }
    }
}
namespace liudazhen
{
    /// <summary>
    /// 包含扩展方法的静态类
    /// </summary>
    public static class ldz
    {
        private static string patternmul = @"N?\d+(\.\d+|\.)?\s*[\*/]\s*N?\d+(\.\d+|\.)?";
        private static string patternadd = @"(\-|N)?\d+(\.\d+|\.)?\s*[\-\+]\s*N?\d+(\.\d+|\.)?";
        private static Regex myregexmul = new Regex(patternmul);
        private static Regex myregexadd = new Regex(patternadd);

        /// <summary>
        /// 对返回的表达式的值进行转换和最后校验.
        /// </summary>
        /// <returns>正常反回 double 值,可能引发异常.</returns>
        public static double ToValue(this string s)
        {
            double x=0;
            if (double.TryParse(calcbracket(s).Replace("N", "-"), out x)) return x;
            throw new Exception("表达式书写有误");
        }

        /// <summary>
        /// 取出运算优先级最高的括号内的表达式,调用求值方法求值.
        /// </summary>
        /// <returns>返回未处理完的可能包括括号的剩余的表达式</returns>
        private static String calcbracket(this string s)
        {
            int n1 = -1, n2 = -1;
            string subs = "",subs2="";
            s.Trim();
            string s2 = s;
            for (int i = 0; i < s.Length; i++)
            {
                if (s[i] == '(')  n1 = i;
                if (s[i] == ')')
                {
                    if (n1 == -1) throw new Exception("右括号不配对");
                    n2 = i;
                    subs=s.Substring(n1, n2 - n1 + 1);
                    subs2 = subs.Substring(1, subs.Length - 2);
                    subs2= calcmul(subs2);
                    subs2 = calcadd(subs2);
                    s2= s.Replace(subs,subs2);
                    return calcbracket(s2);
                }
            }
            if (n2 == -1 && n1 != -1) throw new Exception("左括号不配对");
            subs = calcmul(s);
            subs2 = calcadd(subs);
            return subs2;
        }
        /// <summary>
        /// 取出运算优先级最高的乘法和(或)除法表达式,对其进行求值.
        /// </summary>
        /// <returns>返回未处理完的可能包括乘法和(或)除法的剩余的表达式</returns>
        private static String calcmul(this string s)
        {
            string subs = "",subs2="";
            s.Trim();
            string s2 = s;
            string[] num = null;
            double x1=0,x2 = 0.0,x;
            Match M = myregexmul.Match(s);
            if (M.Success)
            {
                subs = M.Value.Trim();
                subs2 = M.Value.Trim();
                if (subs[0] == '-') subs2 = "N" + subs.Remove(0, 1);
                num = subs2.Split('*', '/');
                double.TryParse((num[0].Replace("N", "-")), out x1);
                double.TryParse((num[1].Replace("N", "-")), out x2);
                if (subs2.Contains('*')) x = x1 * x2;
                else
                {
                    if (x2==0) throw (new Exception("除数为零"));
                    x = x1 / x2;
                }
                s2 = s.Replace(subs, x < 0 ? "N" + (-x).ToString() : x.ToString());
                return calcmul(s2);
            }
            else if (s2[0] == '-') s2 = "N" + s2.Remove(0, 1);
            return s2.Trim();
        }

        /// <summary>
        /// 取出运算优先级最高的加法和(或)减法表达式,对其进行求值.
        /// </summary>
        /// <returns>返回未处理完的可能包括加法和(或)减法的剩余的表达式</returns>
        private static String calcadd(this string s)
        {
            string subs = "",subs2="";
            s.Trim();
            string s2 = s;
            string[] num = null;
            double x1 = 0, x2 = 0.0, x;
            Match M = myregexadd.Match(s);
            if (M.Success)
            {
                subs = M.Value.Trim();
                subs2 = M.Value.Trim();
                if (subs[0] == '-') subs2 = "N" + subs.Remove(0, 1);
                num = subs2.Split('+', '-');
                double.TryParse((num[0].Replace("N", "-")), out x1);
                double.TryParse((num[1].Replace("N", "-")), out x2);
                if (subs2.Contains('+'))
                    x = x1 + x2;
                else
                    x = x1 - x2;
                s2 = s.Replace(subs, x < 0 ? "N" + (-x).ToString() : x.ToString());
                return calcadd(s2);
            }
            else if (s2[0] == '-') s2 = "N" + s2.Remove(0, 1);
            return s2.Trim();
        }
    }
}