四則混合運算表達式分析程序----C#遞歸分析版

 

源碼下載: http://www.gzqzyz.cn/UploadFiles/2008-8/expressionanalyzer.rar

# Token.cs

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
5. namespace OOHacker.ExpressionAnalyzer
6. {
7.   //===========================================================================
8.   // 抽象標記
9.   //===========================================================================
10.   public abstract class Token
11.   {
12.     public abstract object Value { get;}
13.     public override string ToString()
14.     {
15.       return Value.ToString();
16.     }
17.   }
19.   //===========================================================================
20.   // 左括號
21.   //===========================================================================
22.   public class LP : Token
23.   {
24.     public override object Value
25.     {
26.       get
27.       {
28.         return '(';
29.       }
30.     }
31.   }
33.   //===========================================================================
34.   // 右括號
35.   //===========================================================================
36.   public class RP : Token
37.   {
38.     public override object Value
39.     {
40.       get
41.       {
42.         return ')';
43.       }
44.     }
45.   }
47.   //===========================================================================
48.   // 數值
49.   //===========================================================================
50.   public class Number : Token
51.   {
52.     private double val;
53.     public Number(double value)
54.     {
55.       val = value;
56.     }
58.     public override object Value
59.     {
60.       get
61.       {
62.         return val;
63.       }
64.     }
65.   }
67.   //===========================================================================
68.   // 操作符
69.   //===========================================================================
70.   public class Oper : Token
71.   {
72.     private char op;
73.     public Oper(char oper)
74.     {
75.       op = oper;
76.     }
78.     public override object Value
79.     {
80.       get
81.       {
82.         return op;
83.       }
84.     }
85.   }
86. }

# GrammarAnalyzer.CS

1. using System;
2. using System.Text;
3. using System.Collections;
4. using System.Collections.Generic;
7. namespace OOHacker.ExpressionAnalyzer
8. {
9.   public class GrammerAnalyzer
10.   {
11.     //=========================================================================
12.     // 構造函數: 
13.     //   exp: 要分析的表達式
14.     //=========================================================================
15.     public GrammerAnalyzer(string exp)
16.     {
17.       expression = exp;
18.       index = 0;
19.       tokens = new List<Token>();
20.     }
22.     //=========================================================================
23.     // 表達式詞法分析
24.     //=========================================================================
25.     public void Analyze()
26.     {
27.       tokens.Clear();
28.       index = 0;
30.       Token tok = null;
31.       while ((tok = GetToken()) != null)
32.       {
33.         tokens.Add(tok);
34.       }
35.     }
37.     //=========================================================================
38.     // 獲取標記列表
39.     //=========================================================================
40.     public Token[] TokenList
41.     {
42.       get { return tokens.ToArray(); }
43.     }
45.     //=========================================================================
46.     // 分析後讀取一個標記
47.     //=========================================================================
48.     private Token GetToken()
49.     {
50.       Token token = null;
52.       // 忽略空白字符
53.       while (HasChar && char.IsWhiteSpace(CurrentChar)) MoveNext();
54.       if (!HasChar) return null;
56.       if (CurrentChar == '(')             // 左括號
57.       {
58.         token = new LP();
59.       }
60.       else if (CurrentChar == ')')        // 右括號
61.       {
62.         token = new RP();
63.       }
64.       else if (IsOper(CurrentChar))       // 操作符
65.       {   
66.         token = new Oper(CurrentChar);
67.       }
68.       else if (char.IsDigit(CurrentChar)) // 數字
69.       {
70.         bool dotFound = false;
71.         StringBuilder buf = new StringBuilder();
72.         do
73.         {
74.           char c = CurrentChar;
75.           if (dotFound && c == '.')
76.           {
77.             throw new Exception("無效的數字!");
78.           }
80.           buf.Append(c);
81.           MoveNext();
82.         } while (HasChar && (char.IsDigit(CurrentChar) || CurrentChar == '.'));
84.         MovePrev(); // 回溯一次
85.         token = new Number(Convert.ToDouble(buf.ToString()));
86.       }
87.       else
88.       {
89.         throw new Exception("表達式中含有無效字符:'" + CurrentChar + "'!");
90.       }
92.       MoveNext();
93.       return token;
94.     }
96.     //=========================================================================
97.     // 是否操作符
98.     //=========================================================================
99.     private bool IsOper(char c)
100.     {
101.       string opers = "+-*/";
102.       return opers.IndexOf(c) != -1;
103.     }
105.     //=========================================================================
106.     // 是否還有可讀字符
107.     //=========================================================================
108.     private bool HasChar
109.     {
110.       get { return index < expression.Length; }
111.     }
113.     //=========================================================================
114.     // 當前字符
115.     //=========================================================================
116.     private char CurrentChar
117.     {
118.       get { return expression[index]; }
119.     }
121.     //=========================================================================
122.     // 轉到下一字符
123.     //=========================================================================
124.     private void MoveNext()
125.     {
126.       ++index;
127.     }
129.     //=========================================================================
130.     // 轉到上一字符
131.     //=========================================================================
132.     private void MovePrev()
133.     {
134.       --index;
135.     }
137.     private int index;
138.     private string expression;
139.     private List<Token> tokens;
140.   }
141. }

 

# SyntaxAnalyzer.CS

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
5. namespace OOHacker.ExpressionAnalyzer
6. {
7.   //===========================================================================
8.   // 語法樹結點
9.   //===========================================================================
10.   public class SyntaxTreeNode
11.   {
12.     public SyntaxTreeNode(Token tok,
13.       SyntaxTreeNode lc,
14.       SyntaxTreeNode rc,
15.       int nest)
16.     {
17.       token = tok;
18.       lchild = lc;
19.       rchild = rc;
20.       this.nest = nest;
21.     }
23.     //=========================================================================
24.     // 標記
25.     //=========================================================================
26.     public Token Token
27.     {
28.       set { token = value; }
29.       get { return token; }
30.     }
32.     //=========================================================================
33.     // 左孩子
34.     //=========================================================================
35.     public SyntaxTreeNode LChild
36.     {
37.       set { lchild = value; }
38.       get { return lchild; }
39.     }
41.     //=========================================================================
42.     // 右孩子
43.     //=========================================================================
44.     public SyntaxTreeNode RChild
45.     {
46.       set { rchild = value; }
47.       get { return rchild; }
48.     }
50.     //=========================================================================
51.     // 嵌套層數
52.     //=========================================================================
53.     public int Nest
54.     {
55.       set { nest = value; }
56.       get { return nest; }
57.     }
59.     private Token token;
60.     private SyntaxTreeNode lchild;
61.     private SyntaxTreeNode rchild;
62.     private int nest;
63.   }
65.   //===========================================================================
66.   // 語法分析器
67.   //===========================================================================
68.   public class SyntaxAnalyzer
69.   {
70.     public SyntaxAnalyzer(Token[] toks)
71.     {
72.       tokens = toks;
73.       stack = new Stack<SyntaxTreeNode>();
74.       tree = null;
75.       index = 0;
76.     }
78.     //=========================================================================
79.     // 獲取語法樹
80.     //=========================================================================  
81.     public SyntaxTreeNode SyntaxTree
82.     {
83.       get { return tree; }
84.     }
86.     //=========================================================================
87.     // 分析表達式
88.     //=========================================================================  
89.     public void Analyze()
90.     {
91.       // 還原初始狀態
92.       stack.Clear();
93.       index = 0;
94.       tree = null;
95.       nest = 0;
97.       if (!HasToken) return;
99.       // 表達式必須以數值或左括號開頭
100.       if (CurrentToken is Number)
101.       {
102.         N(ref tree);
103.       }
104.       else if (CurrentToken is LP)
105.       {
106.         Lp(ref tree);
107.       }
108.       else
109.       {
110.         throw new Exception("無效表達式! 表達式只能數值或左括號開頭!");
111.       }
113.       if (stack.Count != 0)
114.       {
115.         throw new Exception("無效表達式! 左右括號不配對");
116.       }
117.     }
119.     //=========================================================================
120.     // 數值標記分析
121.     //=========================================================================  
122.     private void N(ref SyntaxTreeNode curr)
123.     {
124.       SyntaxTreeNode node = new SyntaxTreeNode(CurrentToken, 
125.         null, 
126.         null, 
127.         nest);
129.       if (curr == null)
130.       {
131.         curr = node;
132.       }
133.       else
134.       {
135.         if (curr.RChild != null)
136.         {
137.           curr.RChild.RChild = node;
138.         }
139.         else
140.         {
141.           curr.RChild = node;
142.         }
143.       }
145.       MoveNext();
147.       // 數值後的標記必須是操作符或右括號
148.       if (!HasToken) return;
150.       if (CurrentToken is Oper)
151.       {
152.         Op(ref curr);
153.       }
154.       else if (CurrentToken is RP)
155.       {
156.         Rp(ref curr);
157.       }
158.       else
159.       {
160.         throw new Exception("無效表達式! 數值之後發現標記:'" 
161.           + CurrentToken.Value + "'!");
162.       }
163.     }
165.     //=========================================================================
166.     // 左括號分析
167.     //=========================================================================
168.     private void Lp(ref SyntaxTreeNode curr)
169.     {
170.       stack.Push(curr);     // 壓入括號外分析樹
171.       curr = null;          // 清空分析樹
172.       ++nest;               // 嵌套層增加
174.       MoveNext();
175.       if (!HasToken) return;
177.       // 左括號後必須是數值或左括號
178.       if (CurrentToken is Number)
179.       {
180.         N(ref curr);
181.       }
182.       else if (CurrentToken is LP)
183.       {
184.         Lp(ref curr);
185.       }
186.       else
187.       {
188.         throw new Exception("無效表達式! 左括號之後發現標記:'" 
189.           + CurrentToken.Value + "'!");
190.       }
191.     }
193.     //=========================================================================
194.     // 右括號分析
195.     //=========================================================================
196.     private void Rp(ref SyntaxTreeNode curr)
197.     {
198.       if (stack.Count == 0)
199.       {
200.         throw new Exception("無效表達式! 左右括號不配對!");
201.       }
202.       --nest; // 嵌套層遞減
204.       SyntaxTreeNode node = stack.Pop();
205.       if (node != null)
206.       {
207.         // 將括號內表達式樹作爲子樹掛到括號外表達式樹上
208.         if (node.RChild != null)
209.         {
210.           node.RChild.RChild = curr;
211.           curr = node;
212.         }
213.         else
214.         {
215.           node.RChild = curr;
216.           curr = node;
217.         }
218.       }
220.       MoveNext();
221.       if (!HasToken) return;
223.       // 右括號後面必須是操作符或右括號
224.       if (CurrentToken is Oper)
225.       {
226.         Op(ref curr);
227.       }
228.       else if (CurrentToken is RP)
229.       {
230.         Rp(ref curr);
231.       }
232.       else
233.       {
234.         throw new Exception("無效表達式! 右括號之後發現標記:'" 
235.           + CurrentToken.Value + "'!");
236.       }
237.     }
239.     //=========================================================================
240.     // 操作符分析
241.     //=========================================================================
242.     private void Op(ref SyntaxTreeNode curr)
243.     {
244.       SyntaxTreeNode node = new SyntaxTreeNode(CurrentToken, null, null, nest);
246.       // 只有位於同一嵌套層中的操作符有優先級可比性
247.       if ((curr.Token is Oper) 
248.         && (node.Nest == curr.Nest) 
249.         && IsPrior((char)CurrentToken.Value, (char)curr.Token.Value) > 0)
250.       {
251.         node.LChild = curr.RChild;
252.         curr.RChild = node;
253.       }
254.       else
255.       {
256.         node.LChild = curr;
257.         curr = node;
258.       }
260.       MoveNext();
261.       // 操作符之後必須是數或左括號
262.       if (CurrentToken is Number)
263.       {
264.         N(ref curr);
265.       }
266.       else if (CurrentToken is LP)
267.       {
268.         Lp(ref curr);
269.       }
270.       else
271.       {
272.         throw new Exception("無效表達式! 操作符之後發現標記:'" 
273.           + CurrentToken.Value + "'!");
274.       }
275.     }
277.     //=========================================================================
278.     // 比較操作符優先級
279.     //=========================================================================
280.     private int IsPrior(char op1, char op2)
281.     {
282.       int rslt = 0;
283.       if (op1 == '+' || op1 == '-')
284.       {
285.         if (op2 == '*' || op2 == '/')
286.           rslt = -1;
287.       }
288.       else if (op1 == '*' || op1 == '/')
289.       {
290.         if (op2 == '+' || op2 == '-')
291.           rslt = 1;
292.       }
293.       return rslt;
294.     }
296.     //=========================================================================
297.     // 是否還有標記可讀
298.     //=========================================================================
299.     private bool HasToken
300.     {
301.       get { return index < tokens.Length; }
302.     }
304.     //=========================================================================
305.     // 轉到下一標記
306.     //=========================================================================
307.     private void MoveNext()
308.     {
309.       ++index;
310.     }
312.     //=========================================================================
313.     // 當前標記
314.     //=========================================================================  
315.     private Token CurrentToken
316.     {
317.       get { return (Token)tokens[index]; }
318.     }
320.     private int index;
321.     private int nest;
322.     private SyntaxTreeNode tree;
323.     private Token[] tokens;
324.     private Stack<SyntaxTreeNode> stack;
325.   }
326. }

 

# Calculator.CS

1. using System;
2. using System.Text;
3. using System.IO;
5. namespace OOHacker.ExpressionAnalyzer
6. {
7.   //===========================================================================
8.   // 表達式計算器
9.   //===========================================================================
10.   public class Calculator
11.   {
12.     //=========================================================================
13.     // 構造函數
14.     //   tree: 表達式語法樹, 由SyntaxAnalyzer創建;
15.     //=========================================================================
16.     public Calculator(SyntaxTreeNode tree)
17.     {
18.       this.tree = tree;
19.       log = new StringBuilder();
20.     }
22.     //=========================================================================
23.     // 計算表達式值
24.     public double Calc()
25.     {
26.       if (tree == null)
27.       {
28.         throw new Exception("計算樹爲空!");
29.       }
31.       log.Remove(0, log.Length);
32.       return Travel(tree);
33.     }
35.     //=========================================================================
36.     // 求解過程日誌
37.     //=========================================================================
38.     public string Log
39.     {
40.       get { return log.ToString(); }
41.     }
43.     //=========================================================================
44.     // 遍歷表達式分析樹,求取結果
45.     //=========================================================================
46.     private double Travel(SyntaxTreeNode tree)
47.     {
48.       if (tree.Token is Number)
49.       {
50.         return (double)tree.Token.Value;
51.       }
53.       double lsh = Travel(tree.LChild);
54.       double rsh = Travel(tree.RChild);
55.       return Op((char)tree.Token.Value, lsh, rsh);
56.     }
58.     //=========================================================================
59.     // 實際計算操作
60.     //=========================================================================
61.     private double Op(char op, double lsh, double rsh)
62.     {
63.       double rslt = 0;
64.       switch (op)
65.       {
66.         case '+':
67.           rslt = lsh + rsh;
68.           break;
69.         case '-':
70.           rslt = lsh - rsh;
71.           break;
72.         case '*':
73.           rslt = lsh * rsh;
74.           break;
75.         case '/':
76.           if (rsh == 0)
77.           {
78.             throw new Exception("除0溢出!");
79.           }
80.           rslt = lsh / rsh;
81.           break;
82.         default:
83.           throw new Exception("未能識別的操作類型!");
84.       }
85.       
86.       log.AppendFormat("{0,5}{1,5}{2,5}={3,5}/n", lsh, op, rsh, rslt);
87.       return rslt;
88.     }
90.     private SyntaxTreeNode tree;
91.     private StringBuilder log;
92.   }
93. }

 

# 主程序

1. using System;
2. using System.Text;
3. using System.Collections;
4. using OOHacker.ExpressionAnalyzer;
6. class Program
7. {
8.   static void Main(string[] args)
9.   {
10.     string expression;
11.     Console.Write("請輸入表達式:");
12.     expression = Console.ReadLine();
14.     try
15.     {
16.       GrammerAnalyzer ga = new GrammerAnalyzer(expression);
17.       ga.Analyze();
19.       Token[] toks = ga.TokenList;
20.       for (int i = 0; i < toks.Length; ++i)
21.       {
22.         Console.Write(toks[i]);
23.       }
25.       SyntaxAnalyzer sa = new SyntaxAnalyzer(toks);
26.       sa.Analyze();
29.       Calculator calc = new Calculator(sa.SyntaxTree);
30.       double value = calc.Calc();
32.       Console.Write("={0}", value);
34.       Console.WriteLine("/n解析過程:/n{0}", calc.Log);
35.     }
36.     catch (Exception e)
37.     {
38.       Console.WriteLine("錯誤:" + e.Message);
39.     }
41.     Console.Read();
42.   }
43. }

# 測試:

請輸入表達式:(1*2+(3-5)*7)/22+(1-2*3)*5
(1*2+(3-5)*7)/22+(1-2*3)*5=-25.5454545454545
解析過程:
    1    *    2=    2
    3    -    5=   -2
   -2    *    7=  -14
    2    +  -14=  -12
  -12    /   22=-0.545454545454545
    2    *    3=    6
    1    -    6=   -5
   -5    *    5=  -25
-0.545454545454545    +  -25=-25.5454545454545

請輸入表達式:(1+2+3*(1+2+3)/6)*5*(1+2+3)*(1+1)
(1+2+3*(1+2+3)/6)*5*(1+2+3)*(1+1)=360
解析過程:
    1    +    2=    3
    1    +    2=    3
    3    +    3=    6
    3    *    6=   18
   18    /    6=    3
    3    +    3=    6
    6    *    5=   30
    1    +    2=    3
    3    +    3=    6
   30    *    6=  180
    1    +    1=    2
  180    *    2=  360

請輸入表達式:(3+2*(9/3))*10-5/8-3*3*(1+2+3+(1+2+3))
(3+2*(9/3))*10-5/8-3*3*(1+2+3+(1+2+3))=-18.625
解析過程:
    9    /    3=    3
    2    *    3=    6
    3    +    6=    9
    9    *   10=   90
    5    /    8=0.625
   90    -0.625=89.375
    3    *    3=    9
    1    +    2=    3
    3    +    3=    6
    1    +    2=    3
    3    +    3=    6
    6    +    6=   12
    9    *   12=  108
89.375    -  108=-18.625

 

請輸入表達式:1+(2*3)/6*(3+5)
1+(2*3)/6*(3+5)=9
解析過程:
    2    *    3=    6
    6    /    6=    1
    3    +    5=    8
    1    *    8=    8
    1    +    8=    9

請輸入表達式:3+2*(3+1)*5-1
3+2*(3+1)*5-1=42
解析過程:
    3    +    1=    4
    2    *    4=    8
    8    *    5=   40
    3    +   40=   43
   43    -    1=   42

 

,