与或逻辑运算的实现及格式验证

由于最近在做一个文本搜索器的需要，其中包含与或逻辑表达式计算的部分。所以特意封装了一个处理类，算法比较笨，还请大家多多指教！

 

  1     class BoolExpression
  2     {
  3 
  4         internal bool IsRight(string expression)
  5         {
  6             bool isRight = true;
  7 
  8             Regex regex0 = new Regex(@"((T|F)((\||\&)(T|F))*)");
  9             Regex regex1 = new Regex(@"\(_\)");
 10             Regex regex2 = new Regex(@"(_((\||\&)_)*)");
 11 
 12             expression = regex0.Replace(expression, "_");
 13 
 14             while (expression != "_")
 15             {
 16                 if (regex1.IsMatch(expression))
 17                 {
 18                     expression = regex1.Replace(expression, "_");
 19                 }
 20                 else
 21                 {
 22                     isRight = false;
 23                     break;
 24                 }
 25 
 26                 if (regex2.IsMatch(expression))
 27                 {
 28                     expression = regex2.Replace(expression, "_");
 29                 }
 30                 else
 31                 {
 32                     isRight = false;
 33                     break;
 34                 }
 35             }
 36 
 37             return isRight;
 38 
 39         }
 40 
 41         internal bool Calculation(string expression)
 42         {
 43             while (expression != "F" & expression != "T")
 44             {
 45                 char X, Y, logic;
 46 
 47                 for (int i = 0; i < expression.Length; i++)
 48                 {
 49 
 50                     if (expression[i] == 'F' | expression[i] == 'T')
 51                     {
 52                         X = expression[i];
 53 
 54                         if (expression[i + 1] == '|' | expression[i + 1] == '&')
 55                         {
 56                             logic = expression[i + 1];
 57 
 58                             if (expression[i + 2] == 'F' | expression[i + 2] == 'T')
 59                             {
 60                                 Y = expression[i + 2];
 61                             }
 62                             else
 63                             {
 64                                 continue;
 65                             }
 66 
 67                             if (logic == '|')
 68                             {
 69                                 char R = 'F';
 70 
 71                                 if (X == 'T' | Y == 'T')
 72                                 {
 73                                     R = 'T';
 74                                 }
 75 
 76                                 expression = expression.Substring(0, i) + R + expression.Substring(i + 3, expression.Length - i - 3);
 77                                 break;
 78                             }
 79                             else if (logic == '&')
 80                             {
 81                                 char R = 'T';
 82 
 83                                 if (X == 'F' | Y == 'F')
 84                                 {
 85                                     R = 'F';
 86                                 }
 87 
 88                                 expression = expression.Substring(0, i) + R + expression.Substring(i + 3, expression.Length - i - 3);
 89                                 break;
 90 
 91                             }
 92 
 93                         }
 94                         else if (expression[i + 1] == ')')
 95                         {
 96                             expression = expression.Substring(0, i - 1)+expression[i] + expression.Substring(i + 2, expression.Length - i - 2);
 97                             break;
 98                         }
 99                     }
100                     else
101                     {
102                         continue;
103                     }
104 
105                 }
106             }
107 
108             return expression == "T" ? true : false;
109         }
110 
111     }

 

IsRight方法：表达式的正确性检查（利用正则表达式）：
((T|F)((\||\&)(T|F))*)，代表任何一个简单表达式，将简单表达式替换成字符_

循环开始
\(_\)，去掉最里层的括号（每次替换成_）
(_((\||\&)_)*)，替换简单表达式（每次替换成_）
循环结束

若最终能替换成X则代表这是一个正确的表达式，若是在其中任何一步不能匹配则代表这个表达式是存在问题的。




Calculation方法：表达式的计算：
若表达式不能转换成T或者F则始终执行以下操作：
从左向右寻找第一个是T或者F的字符，若后一位是|或者&并且再后一位是T或者F则计算这个表达式，并且用结果替换原来的表达式。
若寻找到第一个的T或者F之后的字符是）则表示简单表达式已经计算完毕，需要讲这个值的左右括号消去。
关于简单二元表达式的计算，若是或计算，将结果预设为F，若两根值其中一个是T，则将结果改为T；若是与运算则结果预设为T，若其中有一个是F，则结果为F。

 

Demo

 

Demo源码

 

 

  算法比较笨，大家有没有用一个正则表达式就能判断逻辑表达式是否正确的方法呢？计算应该也有更好的方法，可以提出来一起学习一下嘛！

posted @ 2012-08-20 15:25  Poerin  阅读(810)  评论(0)  编辑  收藏  举报