经典算法-算术表达式求值

 

经典算法-算术表达式求值

作者:蒋勇 http://www.kipway.com 转载请保留此行

　　表达式的计算应用相当广泛，比如电力调度系统中的计算遥测、车站票务系统中的票价类型计算公式等。
　　本文讲述中置表达式转换为后置表达式和后置表达式的求值算法，并给出实现的C++源代码，同时给出一个相当简洁的堆栈C++模板类。

中缀表达式到后缀表达式的转换
　　要把表达式从中缀表达式的形式转换成用后缀表示法表示的等价表达式，必须了解操作符的优先级和结合性。优先级或者说操作符的强度决定求值顺序；优先级高的操作符比优先级低的操作符先求值。如果所有操作符优先级一样，那么求值顺序就取决于它们的结合性。操作符的结合性定义了相同优先级操作符组合的顺序（从右至左或从左至右）。
转换过程包括用下面的算法读入中缀表达式的操作数、操作符和括号：
1. 初始化一个空堆栈，将结果字符串变量置空。
2. 从左到右读入中缀表达式，每次一个字符。
3. 如果字符是操作数，将它添加到结果字符串。
4. 如果字符是个操作符，弹出（pop）操作符，直至遇见开括号（opening parenthesis）、优先级较低的操作符或者同一优先级的右结合符号。把这个操作符压入（push）堆栈。
5. 如果字符是个开括号，把它压入堆栈。
6. 如果字符是个闭括号（closing parenthesis），在遇见开括号前，弹出所有操作符，然后把它们添加到结果字符串。
7. 如果到达输入字符串的末尾，弹出所有操作符并添加到结果字符串。

后缀表达式求值
　　对后缀表达式求值比直接对中缀表达式求值简单。在后缀表达式中，不需要括号，而且操作符的优先级也不再起作用了。您可以用如下算法对后缀表达式求值：
1. 初始化一个空堆栈
2. 从左到右读入后缀表达式
3. 如果字符是一个操作数，把它压入堆栈。
4. 如果字符是个操作符，弹出两个操作数，执行恰当操作，然后把结果压入堆栈。如果您不能够弹出两个操作数，后缀表达式的语法就不正确。
5. 到后缀表达式末尾，从堆栈中弹出结果。若后缀表达式格式正确，那么堆栈应该为空。

数据结构
　　在这两个算法中都要利用堆栈。因此这里首先给出一个堆栈的C++模板类，这个模板相当间接，只包含了表达式计算中必须要的功能。Pop Push Getsize 如下：
template <class T,int SIZE> class CArrayStackTemp
{
public:
CArrayStackTemp (){top= -1;}; //缺省构造函数,构造一个空堆栈
~CArrayStackTemp (){};//析构函数
bool Push(T element); //入栈
bool Pop(T& element);//出栈
int GetSize(){return top+1;};//取元素个数
private:
T Buffer[SIZE];
int top;
};
template <class T, int SIZE> bool CArrayStackTemp<T, SIZE>:: Push (T element)
{
top++;
if (top>SIZE-1) {top--; return false;}//满
Buffer[top]=element;
return true;
}
template <class T, int SIZE> bool CArrayStackTemp<T, SIZE>:: Pop (T& element)
{
if (top==-1) return false;//空
element=Buffer[top];
top--;
return true;
}

　　本文重在讲述原理和实现，因此以下算法只包含了+-*/()的处理，操作数自动转换为double型浮点数。是y=f(x)函数的计算，因此表达式中支持'X'字符，不分大小写，比如：y=(x-5)+2/(x+1)，下面的算法代码就是计算y值。

中缀表达式到后缀表达式的转换代码
LPCTSTR lpszS:表达式字串
CString &szD:结果
return =0:ok
int g_Mid2Behind(LPCTSTR lpszS,CString &szD)//中置->后置 只支持() + - * / 和X变量
{
CArrayStackTemp <char, 256> stk;//堆栈
CString szs=lpszS,szt="";
szs.TrimLeft(); szs.TrimRight();szs.MakeUpper();//大写
int i,len=szs.GetLength();
char c,cc,buf[256];;
for(i=0;i<len;i++)
{
c=szs[i];
if((c>'9')&&(c!='X')) return 1;//含有非法字符
if((c==' ')||(c=='/t')||(c==0x0d)||(c==0x0a)) continue;
szt+=c;
}
len=szt.GetLength();
if(len > 255) return 2;//太长
sprintf(buf,"%s",szt);
buf[len]=0;
char *p=(char *)buf;
szt=""; szD="";
bool bret;
while(*p != 0)
{
c=*p;
if( ((c>='0')&&(c<='9'))|| (c=='X')|| (c=='.') ){szt+=c;p++;continue;}
else
{
if(!szt.IsEmpty())//操作数,添加到结果字符串
{
len=szt.GetLength();
for(i=0;i<len;i++) szD+=szt[i];
szt="";
}
if((c == '+')||(c=='-'))
{
do
{ if(!stk.Pop(cc)) cc=0;
if((cc!=0)&&(cc!='(')) szD += cc;
}while((cc!=0)&&(cc!='('));
if(cc=='(') stk.Push(cc);
stk.Push(c);
}
else if((c == '*')||(c=='/'))
{
do
{ if(!stk.Pop(cc)) cc=0;
if((cc!=0)&&(cc!='(')&&(cc!='+')&&(cc!='-')) szD += cc;
}while((cc!=0)&&(cc!='(')&&(cc!='+')&&(cc!='-'));
if((cc=='(')||(cc=='-')||(cc=='+')) stk.Push(cc);
stk.Push(c);
}
else if(c == '(') stk.Push(c);
else if(c == ')')
{
do
{ if(!stk.Pop(cc)) cc=0;
if((cc!=0)&&(cc!='(')) szD += cc;
}while((cc!=0)&&(cc!='('));
if(cc=='(') stk.Push(cc);
}
else return 3;//操作符错误
}
p++;
}
if(!szt.IsEmpty())//操作数,添加到结果字符串
{
len=szt.GetLength();
for(i=0;i<len;i++) szD+=szt[i];
szt="";
}
while(stk.GetSize())
{
bret=stk.Pop(cc);
if((bret==true)&&(cc!='(')) szD += cc;
}
return 0;
}

后缀表达式求值代码
LPCTSTR lpszParse:后置表达式
double xval:变量X的值
double *pResult:计算结果
无错时返回TRUE
BOOL CalBehindParse(LPCTSTR lpszParse,double xval,double *pResult)
{
char c;
const char *pc=lpszParse;
double v1,v2;
CArrayStackTemp <double, 256> stk;//堆栈
CString szt="";
while(*pc != NULL)
{
c=*pc;
if(c=='X') stk.Push(xval);
else if( ((c>='0')&&(c<='9')) || (c=='.') ) {szt+=c;pc++;continue;}
else
{
if(!szt.IsEmpty()){ stk.Push(atof(szt));szt=""; }
if(!stk.Pop(v2)) return FALSE;
if(!stk.Pop(v1)) return FALSE;
if(c=='+') stk.Push(v1+v2);
else if(c=='-') stk.Push(v1-v2);
else if(c=='*') stk.Push(v1*v2);
else if(c=='/') stk.Push(v1/v2);
else return FALSE;//非法运算符
}
pc++;
}
if(!szt.IsEmpty()){ stk.Push(atof(szt));szt=""; }
if(stk.GetSize()!=1) return FALSE;
return stk.Pop(*pResult);
}

把 CalBehindParse()稍作修改就可以得到后置表达式正确性检查的函数，如下：
BOOL CheckBehindParse(LPCTSTR lpszParse)//检查后置表达式
{
char c;
const char *pc=lpszParse;
double v1,v2;
CArrayStackTemp <double, 256> stk;
CString szt="";
while(*pc != NULL)
{
c=*pc;
if(c=='X') stk.Push(1);
else if( ((c>='0')&&(c<='9')) || (c=='.') ) {szt+=c;pc++;continue;}
else
{
if(!szt.IsEmpty()){stk.Push(atof(szt)); szt=""; }
if(!stk.Pop(v2)) return FALSE;
if(!stk.Pop(v1)) return FALSE;
if((c=='+')||(c=='-')||(c=='*')||(c=='/')) stk.Push(1);
else return FALSE;//非法运算符
}
pc++;
}
if(stk.GetSize()!=1) return FALSE;
return TRUE;
}

综合以上这些函数，可以得到中置表达式的直接计算和检查函数：
BOOL CheckParse(LPCTSTR lpszParse)//检查中置表达式是否正确
{
CString szb;
if(0!=g_Mid2Behind(lpszParse,szb))
return FALSE;
if(szb.IsEmpty()) return TRUE;
return CheckBehindParse(szb);
}
BOOL CalParse(LPCTSTR lpszParse,double dblVar,double *pResult)//计算中置表达式
{
CString szb;
if(0!=g_Mid2Behind(lpszParse,szb))
return FALSE;
if(szb.IsEmpty()){*pResult=0; return TRUE;}
return CalBehindParse(szb,dblVar,pResult);
}

你可以用下面的测试例子去测试上面的函数：
double dblResult;
BOOL bret=CalParse("X / 2 * (X + 2.5)",2,&dblResult);//计算中置表达式

注：本文的代码在windows xp，VC++6 + vcsp5环境下验证通过。

-----------------------------------------------------------------------------------------------

表达式求值的经典算法

编写代码对算术表达式求值的经典方法由 Donald Knuth 描述于 1962 年（请参阅 参考资料）。Knuth 将此概括为三个步骤：

• 对中缀表达式进行语法分析
• 中缀表达式到后缀表达式的转换
• 对后缀表达式求值

注意到我们谈到的这个经典算法有些简化：算术表达式只包含操作数、二元操作符和一种括号。此外，对于每个操作数和操作符，只用单个字符表示，使语法分析直观。

表达式表示法

算术表达式中最常见的表示法形式有 中缀、前缀和 后缀表示法。中缀表示法是书写表达式的常见方式，而前缀和后缀表示法主要用于计算机科学领域。

中缀表示法
中缀表示法是算术表达式的常规表示法。称它为 中缀表示法是因为每个操作符都位于其操作数的中间，这种表示法只适用于操作符恰好对应两个操作数的时候（在操作符是二元操作符如加、减、乘、除以及取模的情况下）。对以中缀表示法书写的表达式进行语法分析时，需要用括号和优先规则排除多义性。

Syntax: operand1 operator operand2
Example: (A+B)*C-D/(E+F)

前缀表示法
前缀表示法中，操作符写在操作数的前面。这种表示法经常用于计算机科学，特别是编译器设计方面。为纪念其发明家 ― Jan Lukasiewicz（请参阅 参考资料），这种表示法也称 波兰表示法。

Syntax  : operator operand1 operand2
Example : -*+ABC/D+EF

后缀表示法
在后缀表示法中，操作符位于操作数后面。后缀表示法也称 逆波兰表示法（reverse Polish notation，RPN），因其使表达式求值变得轻松，所以被普遍使用。

Syntax  : operand1 operand2 operator
Example : AB+C*DEF+/-

前缀和后缀表示法有三项公共特征：

• 操作数的顺序与等价的中缀表达式中操作数的顺序一致
• 不需要括号
• 操作符的优先级不相关

中缀表达式到后缀表达式的转换

要把表达式从中缀表达式的形式转换成用后缀表示法表示的等价表达式，必须了解操作符的优先级和结合性。 优先级或者说操作符的强度决定求值顺序；优先级高的操作符比优先级低的操作符先求值。 如果所有操作符优先级一样，那么求值顺序就取决于它们的 结合性。操作符的结合性定义了相同优先级操作符组合的顺序（从右至左或从左至右）。

Left associativity  : A+B+C = (A+B)+C
Right associativity : A^B^C = A^(B^C)

转换过程包括用下面的算法读入中缀表达式的操作数、操作符和括号：

1. 初始化一个空堆栈，将结果字符串变量置空。
2. 从左到右读入中缀表达式，每次一个字符。
3. 如果字符是操作数，将它添加到结果字符串。
4. 如果字符是个操作符，弹出（pop）操作符，直至遇见开括号（opening parenthesis）、优先级较低的操作符或者同一优先级的右结合符号。把这个操作符压入（push）堆栈。
5. 如果字符是个开括号，把它压入堆栈。
6. 如果字符是个闭括号（closing parenthesis），在遇见开括号前，弹出所有操作符，然后把它们添加到结果字符串。
7. 如果到达输入字符串的末尾，弹出所有操作符并添加到结果字符串。

后缀表达式求值

对后缀表达式求值比直接对中缀表达式求值简单。在后缀表达式中，不需要括号，而且操作符的优先级也不再起作用了。您可以用如下算法对后缀表达式求值：

1. 初始化一个空堆栈
2. 从左到右读入后缀表达式
3. 如果字符是一个操作数，把它压入堆栈。
4. 如果字符是个操作符，弹出两个操作数，执行恰当操作，然后把结果压入堆栈。如果您不能够弹出两个操作数，后缀表达式的语法就不正确。
5. 到后缀表达式末尾，从堆栈中弹出结果。若后缀表达式格式正确，那么堆栈应该为空。