“中序表达式”转换为“前序表达式”、“后序表达式”

上周末参照书本写了个“计算器”的程序，其中最令我费解的就是“前序表达式”、“后续表达式”，好像记得老师在上课的时候讲过，估计当时也没听懂，看的稀里糊涂的，不过现在大概明白了……

　　在此仅做以笔记。

 首先看下面所示表格：

中序表达式	2*3/(2-1)+3*(4-1)
前序表达式	+/*23-21*3-41
后序表达式	23*21-/341-*+

 　　中序表达式对我们而言是很直观的（我们平时接触的就是这个），但计算机处理起来比较麻烦（括号、优先级之类的），前序和后序表达式中没有括号，而且在计算中只需单向扫描，不需要考虑运算符的优先级。
　　以前序表达式“+/*23-21*3-41”为例，从右往左，先取出两个操作数“1”、“4”和一个运算符“-”，计算“4-1”，将结果3回填到字符串中，现在字符串变为“+/*23-21*33”。
　　再从右至左取两个数“3”、“3”和“*”，计算“3*3”，将结果“9”回填到字符串，得“+/*23-219’”,

　　再取数，连续取出“9”、“1”、“2”，直到取出一个运算符“-”，将与运算符最近的两个操作数进行计算，即“2-1”得“1”，回填字符串中，现在为“+/*239”
　　重复上述步骤，取出“2*3”=6，回填字符串得到“+/619”，

　　再取“6/1”=6，得到“+69”,

　　再取“6+9”=15。运算完毕。

　　即从右至左取数，直到取出一个运算符，将刚取出的紧挨着运算符的两个操作数按运算符进行计算，结果回填至运算符。重复该步骤，直到最后只剩下一个字符串则剩下的字符串即为结果。
　　后序表达式的字符串扫描方式正好和前序相反，是从左往右扫描，规则类似。 

中序表达式转前序表达式步骤
1 、反转输入字符串，如“ 2 * 3 / ( 2 - 1 ) + 3 * ( 4 - 1 )” 反转后为“ ) 1 - 4 ( * 3 + ) 1 - 2 ( / 3 * 2 ”，
2 、从字符串中取出下一个字符
　　 2.1 .如果是操作数，则直接输出
　　 2.2 .如果是“)”，压入栈中
　　 2.3 .如果是运算符但不是“(”，“)”,则不断循环进行以下处理
　　　　 2.3.1. 如果栈为空，则此运算符进栈，结束此步骤
　　　　 2.3.2. 如果栈顶是“)”,则此运算符进栈，结束此步骤
　　　　 2.3.2. 如果此运算符与栈顶优先级相同或者更高，此运算符进栈，结束此步骤
　　　　 2.3.4. 否则，运算符连续出栈，直到满足上述三个条件之一，然后此运算符进栈
　　 2.4 、如果是“(”，则运算符连续出栈，直到遇见“)”为止,将“)”出栈且丢弃之
3 、如果还有更多的字符串，则转到第2步
4 、不在有未处理的字符串了，输出栈中剩余元素
5 、再次反转字符串得到最终结果

 　　我第一次看到这个的时候就没看懂是什么意思，在网上查了点，又瞪了它好久才明白了，就以“2*3/(2-1)+3*(4-1)，”为例做以下说明：
　　2*3/(2-1)+3*(4-1)，反转得“ )1-4(*3+)1-2(/3*2 ”；
　　取第一个字符串为“）”，入栈（此时栈中为“）”）；
　　取下一个“1”，是操作数，直接输出（目前输出“1”）；
　　取下一个“-”，既不是“)”,也不是“（”，则转到2.3，此时栈顶为“）”,则该运算符进栈（栈中为“-、）”）；
　　取下一个“4”，直接输出（目前输出的是“14”）；
　　取下一个“(”，运算符连续出栈（栈中此时为“-、）”），直到遇见“)”,此时输出“-”（目前输出“14-”，栈为空）；
　　取下一个“*”，既不是“)”,也不是“（”，则转到2.3，进栈（栈为空）；
　　取下一个“3”，直接输出（目前输出“14-3”）；
　　取下一个“+”，此时栈顶为“*”,“+”的优先级比“*”低（2.3.4），则运算符连续出栈（只有一个*出栈，此时栈为空符合2.3.1，继续下一步），“+”进栈；
　　取下一个“)”，进栈（此时栈中为“）、+”）；
　　取下一个“1”直接输出（目前输出为14-3*1）；
　　取下一个“-”，此时栈顶为“）”，“-”进栈（栈中此时为“-、）、+”）；
　　取下一个“2”，直接输出（目前输出“14-3*12”）；
　　取下一个“（”，运算符连续出栈，直到遇见“）”，此时栈中为“-、）、+”，输出-，且抛弃“）”，此时输出为“14-3*12-”,栈中为“+”；
　　取下一个“/”，优先级比栈顶“+”高，此运算符进栈；
　　取下一个“3”，直接输出（此时输出“14-3*12-3”）；
　　取下一个“*”，优先级比栈顶“+”高，此运算符进栈；
　　取下一个“2”，输出（此时输出“14-3*12-32”）；
　　不在有未处理的运算符，输出栈中剩余元素,结果的“14-3*12-32*/+”；
　　反转字符串的“+/*23-21*3-41”。

 

　　程序实现完整代码

完整代码

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


namespace  ConsoleApplication7
{
     class  program
    {
         static   void  Main()
        {
            MyExpression myExpr  =   new  MyExpression();
             // string str = "5.5+8*3-(4*2)";
             string  str  =   " 2*3/(2-1)+3*(4-1) " ;
             // string str = "5*4-1";
            Console.WriteLine( " 原表达式： "   +  str);
            myExpr.Expression  =  str;
            myExpr.calcaute();
            Console.ReadKey();
        }

    }

     class  MyExpression
    {
         ///   <summary>
         ///  运算表达式
         ///   </summary>
         public   string  Expression
        {
             get ;
             set ;
        }

         //  新的表达式（由前序或后续表达式转换而来，即最终参与运算的表达式）        
         private  ArrayList newExpression  =   new  ArrayList();

         // 队列  ，对数据处理，识别数字，如11+8识别出11和8 
         private  Queue queueTmp  =   new  Queue();

         // 数组，将转变后的数据放入数组
         private  ArrayList arrltmp  =   new  ArrayList();

         // 栈，将中序表达式转为前序表达式时使用
        Stack stackTmp  =   new  Stack();

         #region  处理字符串中的数字

         ///   <summary>
         ///  处理字符串中的数字
         ///   </summary>
         private   void  HandleNumberinExpression()
        {
             string  expression  =   this .Expression.Trim();
             foreach  ( char  character  in  Expression)
            {                
                 string  tmp  =   "" ;
                 // 如果不是运算符，则放入Queue，直到遇到运算符，
                 if  ( ! IsOperator(character.ToString()))
                {
                    queueTmp.Enqueue(character.ToString());
                }
                 else
                {
                     // 运算符，先将Queue中的数据输出从而得到一个数字(如1和1，得到11)，并将得到的数字放入ArrayList
                     int  count  =  queueTmp.Count;
                     // Count不为0 ，里面存放的就是数字，否则就是null（连着几个运算符情况，如“*（”）
                     if  (count  !=   0 )
                    {
                         for  ( int  i  =   0 ; i  <  count; i ++ )
                        {
                            tmp  +=  queueTmp.Dequeue();
                        }
                        arrltmp.Add(tmp);
                    }
                     // 放入运算符
                    arrltmp.Add(character.ToString());
                }
            }
             // 得到最后一个数字(最后一个不是“）”，就是数字)
             string  end  =   "" ;
             int  QueueCount  =  queueTmp.Count;
             if  (QueueCount  !=   0 )
            {
                 for  ( int  i  =   0 ; i  <  QueueCount; i ++ )
                {
                    end  +=  queueTmp.Dequeue();
                }
                arrltmp.Add(end);
            }             
        }

         #endregion       


         #region  将中序表达式转为后序表达式

         ///   <summary>
         ///  将中序表达式转为后序表达式
         ///   </summary>
         private   void  ChangeMiddleToAfter()
        {           
             foreach  ( string  s  in  arrltmp)
            {
                 // 如果是操作数，直接输出
                 if  ( ! IsOperator(s))
                {                  
                    newExpression.Add(s);
                }
                 // 如果是“（”，压入栈中
                 else   if  (s  ==   " ( " )
                {
                    stackTmp.Push(s);
                }
                 // 如果是右括号，则运算符连续出栈，直到遇见左括号为止，左括号出栈且丢弃它
                 else   if  (s  ==   " ) " )
                {
                     // 右括号
                     while  (stackTmp.Count  >   0   &&  stackTmp.Peek().ToString()  !=   " ( " )
                    {
                         string  ss  =  stackTmp.Pop().ToString();                      
                        newExpression.Add(ss);
                    }
                    stackTmp.Pop();
                }
                 // 是运算符，且不是右括号，不断循环进行
                 else
                {
                     // 如果栈为空，次运算符进栈，结束此步骤，取下一个字符
                     if  (stackTmp.Count  ==   0 )
                    {
                        stackTmp.Push(s);
                    }
                     // 如果栈顶是“（”，此运算符进栈，结束次步骤，读取下一个字符
                     else   if  (stackTmp.Peek().ToString()  ==   " ( " )
                    {
                        stackTmp.Push(s);
                    }
                     // 如果此运算符与栈顶优先级相同或更高，此运算符进栈，结束次步骤，取下一个字符，
                     else   if  (myOperator.notBiggerthan(s.ToString(), stackTmp.Peek().ToString()))
                    {
                       newExpression.Add(stackTmp.Pop());
                        stackTmp.Push(s);
                    }
                     // 否则，运算符连续出栈，直至满足上述三个条件之一退出此步骤
                     else
                    {
                         do
                        {                          
                            stackTmp.Push(s);                            
                        }  while  ( ! (stackTmp.Count  ==   0   ||
                            stackTmp.Peek().ToString()  ==   " ( "   ||
                            myOperator.notBiggerthan(s.ToString(), stackTmp.Peek().ToString())));
                    }
                }
            }
             while  (stackTmp.Count  !=   0 )
            {
                 string  popstr  =  stackTmp.Pop().ToString();            
                newExpression.Add(popstr);
            }
        }
         #endregion


         #region  将中序表达式转为前序表达式

         ///   <summary>
         ///  将中序表达式转为前序表达式
         /// </summary>
         private   void  ChangeMiddleToBefore()
        {
             // 将处理后的数组反转
            arrltmp.Reverse();            
             foreach  ( string  s  in  arrltmp)
            {                         
                 // 如果是操作数，直接输出
                 if  ( ! IsOperator(s))
                {                 
                    newExpression.Add(s);
                }
                 // 如果是“）”，压入栈中
                 else   if  (s  ==   " ) " )
                {
                    stackTmp.Push(s);
                }
                 // 如果是左括号，则运算符连续出栈，直到遇见右括号为止，右括号出栈且丢弃它
                 else   if  (s  ==   " ( " )
                {
                     // 右括号
                     while  (stackTmp.Count  >   0   &&  stackTmp.Peek().ToString()  !=   " ) " )
                    {
                         string  ss  =  stackTmp.Pop().ToString();                        
                        newExpression.Add(ss);
                    }
                    stackTmp.Pop();
                }
                 // 是运算符，且不是左括号，不断循环进行
                 else
                {
                     // 如果栈为空，次运算符进栈，结束此步骤，取下一个字符
                     if  (stackTmp.Count  ==   0 )
                    {
                        stackTmp.Push(s);
                    }
                     // 如果栈顶是“）”，此运算符进栈，结束次步骤，读取下一个字符
                     else   if  (stackTmp.Peek().ToString()  ==   " ) " )
                    {
                        stackTmp.Push(s);
                    }
                     // 如果此运算符与栈顶优先级相同或更高，此运算符进栈，结束次步骤，取下一个字符，
                     else   if  (myOperator.notLessthan(s.ToString(), stackTmp.Peek().ToString()))
                    {
                        stackTmp.Push(s);
                    }
                     // 否则，运算符连续出栈，直至满足上述三个条件之一退出此步骤
                     else
                    {
                         do
                        {
                             string  podstr  =  stackTmp.Pop().ToString();                           
                            newExpression.Add(podstr);
                        }  while  ( ! (stackTmp.Count  ==   0   ||
                            stackTmp.Peek().ToString()  ==   " ) "   ||
                            myOperator.notLessthan(s.ToString(), stackTmp.Peek().ToString())));

                        stackTmp.Push(s);
                       
                    }
                }
            }
             while (stackTmp.Count  !=   0 )
            {
                 string  popstr  =  stackTmp.Pop().ToString();             
                newExpression.Add(popstr);
            }
        }
         #endregion  

         ///   <summary>
         ///  计算
         ///   </summary>
         public   void  calcaute()
        {
             // 进行第一次处理，识别数字
            HandleNumberinExpression();

             // 中序表达式转为后序表达式
            ChangeMiddleToAfter();
            Console.Write( " 后序表达式： " );
             foreach  ( string  t  in  newExpression)
            {
                Console.Write(t);
            }
            calcauteAfterExpression();

             /// /中序表达式转为前序表达式
             // ChangeMiddleToBefore();
             // Console.Write("倒序的前序表达式：");
             // foreach (string t in newExpression)
             // {
             //     Console.Write(t);
             // }
             // calcauteBeforeExpression();

            Console.WriteLine( " \n计算结果：  "   +  newExpression[ 0 ]);
        }

         #region  计算前序表达式

         ///   <summary>
         ///  计算前序表达式
         ///   </summary>
         private   void  calcauteBeforeExpression()
        {
             double  result  =   0 ;
             if  (newExpression.Count  >   1 )
            {
                 int  i  =   0 ;
                 for  (i  =   0 ; i  <  newExpression.Count; i ++ )
                {
                     if  (IsOperator(newExpression[i].ToString()))
                    {
                         if  (newExpression[i].ToString()  ==   " + " )
                        {
                            result  =  Convert.ToDouble(newExpression[i  -   1 ])  +  Convert.ToDouble(newExpression[i  -   2 ]);
                        }
                         else   if  (newExpression[i].ToString()  ==   " - " )
                        {
                            result  =  Convert.ToDouble(newExpression[i  -   1 ])  -  Convert.ToDouble(newExpression[i  -   2 ]);
                        }
                         else   if  (newExpression[i].ToString()  ==   " * " )
                        {
                            result  =  Convert.ToDouble(newExpression[i  -   1 ])  *  Convert.ToDouble(newExpression[i  -   2 ]);
                        }
                         else   if  (newExpression[i].ToString()  ==   " / " )
                        {
                            result  =  Convert.ToDouble(newExpression[i  -   1 ])  /  Convert.ToDouble(newExpression[i  -   2 ]);
                        }
                         break ;
                    }
                }
                newExpression[i]  =  result;
                newExpression.RemoveAt(i  -   1 );
                newExpression.RemoveAt(i  -   2 );
                calcauteBeforeExpression();
            }
             else
            {
               
            }
        }
         #endregion

         #region  计算后序表达式
         ///   <summary>
         ///  计算后序表达式
         ///   </summary>
         private   void  calcauteAfterExpression()
        {
             double  result  =   0 ;
             if  (newExpression.Count  >   1 )
            {
                 int  i  =   0 ;
                 for  (i  =   0 ; i  <  newExpression.Count; i ++ )
                {
                     if  (IsOperator(newExpression[i].ToString()))
                    {
                         if  (newExpression[i].ToString()  ==   " + " )
                        {
                            result  =  Convert.ToDouble(newExpression[i  -   2 ])  +  Convert.ToDouble(newExpression[i  -   1 ]);
                        }
                         else   if  (newExpression[i].ToString()  ==   " - " )
                        {
                            result  =  Convert.ToDouble(newExpression[i  -   2 ])  -  Convert.ToDouble(newExpression[i  -   1 ]);
                        }
                         else   if  (newExpression[i].ToString()  ==   " * " )
                        {
                            result  =  Convert.ToDouble(newExpression[i  -   2 ])  *  Convert.ToDouble(newExpression[i  -   1 ]);
                        }
                         else   if  (newExpression[i].ToString()  ==   " / " )
                        {
                            result  =  Convert.ToDouble(newExpression[i  -   2 ])  /  Convert.ToDouble(newExpression[i  -   1 ]);
                        }
                         break ;
                    }
                }
                newExpression[i]  =  result;
                newExpression.RemoveAt(i  -   1 );
                newExpression.RemoveAt(i  -   2 );
                calcauteAfterExpression();
            }
             else
            {
                 // Console.WriteLine(result);
            }
        }
         #endregion

         #region  判断是否是运算符，包括+-*/（）
         ///   <summary>
         ///  判断是否是运算符，包括+-*/（）
         ///   </summary>
         ///   <param name="character"></param>
         ///   <returns></returns>
         private   bool  IsOperator( string  str)
        {
             if  (str.ToString()  !=   " + "   &&  str.ToString()  !=   " - "   &&  str.ToString()  !=   " * "   &&  str.ToString()  !=   " / "   &&  str.ToString()  !=   " ( "   &&  str.ToString()  !=   " ) " )
            {
                 return   false ;
            }
             else
            {
                 return   true ;
            }
        }

         #endregion
    }



     class  myOperator
    {
         ///   <summary>
         ///  比较运算符优先级，operator_1不小于operator_2
         ///   </summary>
         ///   <param name="operator_1"></param>
         ///   <param name="operator_2"></param>
         ///   <returns></returns>
         public   static   bool  notLessthan( string  operator_1,  string  operator_2)
        {
             int  tmp_1  =  change(operator_1);
             int  tmp_2  =  change(operator_2);
             if  (tmp_1  >=  tmp_2)
            {
                 return   true ;
            }
             else
            {
                 return   false ;
            }
        }

         ///   <summary>
         ///  比较运算符优先级，operator_1不大于operator_2
         ///   </summary>
         ///   <param name="operator_1"></param>
         ///   <param name="operator_2"></param>
         ///   <returns></returns>
         public   static   bool  notBiggerthan( string  operator_1,  string  operator_2)
        {
             int  tmp_1  =  change(operator_1);
             int  tmp_2  =  change(operator_2);
             if  (tmp_1  <=  tmp_2)
            {
                 return   true ;
            }
             else
            {
                 return   false ;
            }
        }

         ///   <summary>
         ///  给运算符赋优先级
         ///   </summary>
         ///   <param name="myOperator"></param>
         ///   <returns></returns>
         private   static   int  change( string  myOperator)
        {
             switch  (myOperator)
            {
                 case   " + " :
                     return   1 ;
                 case   " - " :
                     return   1 ;
                 case   " * " :
                     return   2 ;
                 case   " / " :
                     return   2 ;
                 default :
                     return   0 ;
            }
        }
    }
}

  在上述处理中需要首先对输入的字符串进行处理，识别出运算符和操作数，另外在计算前序表达式结果的时候我并没有将其反转，而是直接参与了运算（计算的时候是从左往右计算的，参与运算的是反转的前序表达式，结果是一样的）。