表达式计算器的实现
一、前言
关于表达式计算器的实现，在这里分享一下我的思路，也希望大家提出一些改进建议。
二、实现表达式计算的主要思路。
1、使用的数据结构。
以前的版本实现表达式计算用的是二叉树数据结构，二叉树有两个子节点，最多支持双目运算符或者带两个参数的函数，可是如果函数的参数很多，就不好处理了，所以当前的版本，用的数据结构是动态数组，实现原理就是先把字符串表达式转换成动态数组，数组中存储运算符、参与运算的数、括号等。这样运算符或者函数的参数个数就不受限制，可以支持更多类型的运算符。
2、对运算符进行分类。
对运算符的分类处理是该程序的一个重要思路，运算符虽然有很多，但是可以将运算符归类，针对每一类运算符分别处理，这样核心算法就不会涉及到具体的运算符，只会涉及到运算符的类别。这样以后如果要扩展更多的运算符就会很方便，不需要再修改核心算法的代码，只需要修改运算符集合类就可以了。
用一个枚举类表示运算符的种类，代码如下：
/// <summary>
/// 运算符类型
/// </summary>
enum OpeType
{
/// <summary>
/// 该运算因子不是运算符
/// </summary>
notOperator,
/// <summary>
/// 常数或变量(没有参数的运算符)
/// </summary>
noParameter,
/// <summary>
/// '+'或'-'
/// 这两个运算符即可以当正负号使用又可以当加减运算符使用
/// </summary>
PlusOrMinus,
/// <summary>
/// 参数全在左边的运算符
/// </summary>
left,
/// <summary>
/// 参数全在右边的运算符
/// </summary>
right,
/// <summary>
/// 左边和右边都有参数的运算符
/// </summary>
bothSides,
/// <summary>
/// 左括号
/// </summary>
leftParenthesis,
/// <summary>
/// 右括号
/// </summary>
rightParenthesis,
/// <summary>
/// 分隔符，这里指逗号
/// </summary>
Separator
}
3、对表达式的进行合法性检查的思路。
对表达式的合法性检查，我没有学过编译原理，不懂什么是文法分析、词法分析。这个程序检查表达式的合法性的原理是：针对每一类运算符，分别进行判断，检查其参数的个数，参数是在右边还是在左边等等，主要代码如下：
#region 第四次处理
//第四次处理，判断表达式是否合法，并在合适的地方插入乘号
for (int i = 0; i < valList.Count - 1; i++)
{
#region 当前运算因子是数字
if (valList[i].type == ValType.Number)//数字
{
if (valList[i + 1].type == ValType.Operator)//右边是运算符
{
switch (valList[i + 1].OpeType)
{
case OpeType.bothSides://正确
break;
case OpeType.left://正确
break;
case OpeType.leftParenthesis:
Insert(opeList.GetOpe("*"), i + 1);
break;
case OpeType.noParameter:
Insert(opeList.GetOpe("*"), i + 1);
break;
case OpeType.PlusOrMinus://正确
break;
case OpeType.right:
Insert(opeList.GetOpe("*"), i + 1);
break;
case OpeType.rightParenthesis://正确
break;
case OpeType.Separator://正确
break;
}
}
else//右边是数字
{
Insert(opeList.GetOpe("*"), i + 1);
}
}
#endregion
#region 当前运算因子是运算符
if (valList[i].type == ValType.Operator)//运算符
{
#region 当前运算符右边是运算符
if (valList[i + 1].type == ValType.Operator)//右边是运算符
{
switch (valList[i].OpeType)//左运算符
{
#region case OpeType.bothSides://左运算符参数信息
case OpeType.bothSides://左运算符参数信息
switch (valList[i + 1].OpeType)//右运算符
{
case OpeType.bothSides:
MakeException(i);
break;
case OpeType.left:
MakeException(i);
break;
case OpeType.leftParenthesis://正确
break;
case OpeType.noParameter://正确
break;
case OpeType.PlusOrMinus:
MakeException(i);
break;
case OpeType.right://正确
break;
case OpeType.rightParenthesis:
MakeException(i);
break;
case OpeType.Separator:
MakeException(i);
break;
}
break;
#endregion
#region case OpeType.left://左运算符参数信息
case OpeType.left://左运算符参数信息
switch (valList[i + 1].OpeType)//右运算符
{
case OpeType.bothSides://正确
break;
case OpeType.left://正确
break;
case OpeType.leftParenthesis:
Insert(opeList.GetOpe("*"), i + 1);
break;
case OpeType.noParameter:
Insert(opeList.GetOpe("*"), i + 1);
break;
case OpeType.PlusOrMinus://正确
break;
case OpeType.right:
Insert(opeList.GetOpe("*"), i + 1);
break;
case OpeType.rightParenthesis://正确
break;
case OpeType.Separator: //正确
break;
}
break;
#endregion
#region case OpeType.leftParenthesis://左运算符参数信息
case OpeType.leftParenthesis://左运算符参数信息
switch (valList[i + 1].OpeType)//右运算符
{
case OpeType.bothSides:
int pos = i + 1 >= 0 ? i + 1 : i;
MakeException(pos);
break;
case OpeType.left:
pos = i + 1 >= 0 ? i + 1 : i;
MakeException(pos);
break;
case OpeType.leftParenthesis://正确
break;
case OpeType.noParameter://正确
break;
case OpeType.PlusOrMinus://正确
break;
case OpeType.right://正确
break;
case OpeType.rightParenthesis:
pos = i - 1 >= 0 ? i - 1 : i;
MakeException(pos);
break;
case OpeType.Separator:
pos = i - 1 >= 0 ? i - 1 : i;
MakeException(pos);
break;
}
break;
#endregion
#region case OpeType.noParameter://左运算符参数信息
case OpeType.noParameter://左运算符参数信息
switch (valList[i + 1].OpeType)//右运算符
{
case OpeType.bothSides://正确
break;
case OpeType.left://正确
break;
case OpeType.leftParenthesis:
Insert(opeList.GetOpe("*"), i + 1);
break;
case OpeType.noParameter:
Insert(opeList.GetOpe("*"), i + 1);
break;
case OpeType.PlusOrMinus://正确
break;
case OpeType.right:
Insert(opeList.GetOpe("*"), i + 1);
break;
case OpeType.rightParenthesis://正确
break;
case OpeType.Separator: //正确
break;
}
break;
#endregion
#region case OpeType.PlusOrMinus://左运算符参数信息
case OpeType.PlusOrMinus://左运算符参数信息
switch (valList[i + 1].OpeType)//右运算符
{
case OpeType.bothSides:
MakeException(i);
break;
case OpeType.left:
MakeException(i);
break;
case OpeType.leftParenthesis://正确
break;
case OpeType.noParameter://正确
break;
case OpeType.PlusOrMinus:
MakeException(i);
break;
case OpeType.right://正确
break;
case OpeType.rightParenthesis:
MakeException(i);
break;
case OpeType.Separator:
MakeException(i);
break;
}
break;
#endregion
#region case OpeType.right://左运算符参数信息
case OpeType.right://左运算符参数信息
switch (valList[i + 1].OpeType)//右运算符
{
case OpeType.bothSides:
MakeException(i);
break;
case OpeType.left:
MakeException(i);
break;
case OpeType.leftParenthesis://正确
break;
case OpeType.noParameter:
MakeException(i);
break;
case OpeType.PlusOrMinus:
MakeException(i);
break;
case OpeType.right:
MakeException(i);
break;
case OpeType.rightParenthesis:
MakeException(i);
break;
case OpeType.Separator:
MakeException(i);
break;
}
break;
#endregion
#region case OpeType.rightParenthesis://左运算符参数信息
case OpeType.rightParenthesis://左运算符参数信息
switch (valList[i + 1].OpeType)//右运算符
{
case OpeType.bothSides://正确
break;
case OpeType.left://正确
break;
case OpeType.leftParenthesis:
Insert(opeList.GetOpe("*"), i + 1);
break;
case OpeType.noParameter:
Insert(opeList.GetOpe("*"), i + 1);
break;
case OpeType.PlusOrMinus://正确
break;
case OpeType.right:
Insert(opeList.GetOpe("*"), i + 1);
break;
case OpeType.rightParenthesis://正确
break;
case OpeType.Separator://正确
break;
}
break;
#endregion
#region case OpeType.Separator://左运算符参数信息
case OpeType.Separator://左运算符参数信息
switch (valList[i + 1].OpeType)//右运算符
{
case OpeType.bothSides:
MakeException(i + 1);
break;
case OpeType.left:
MakeException(i + 1);
break;
case OpeType.leftParenthesis://正确
break;
case OpeType.noParameter://正确
break;
case OpeType.PlusOrMinus://正确
break;
case OpeType.right://正确
break;
case OpeType.rightParenthesis:
MakeException(i);
break;
case OpeType.Separator:
MakeException(i);
break;
}
break;
#endregion
}
}
#endregion
#region 当前运算符右边是数字
else if (valList[i + 1].type == ValType.Number)//运算符右边是数字
{
switch (valList[i].OpeType)
{
case OpeType.bothSides://正确
break;
case OpeType.left:
Insert(opeList.GetOpe("*"), i + 1);
break;
case OpeType.leftParenthesis://正确
break;
case OpeType.noParameter:
Insert(opeList.GetOpe("*"), i + 1);
break;
case OpeType.PlusOrMinus://正确
break;
case OpeType.right:
MakeException(i);
break;
case OpeType.rightParenthesis:
Insert(opeList.GetOpe("*"), i + 1);
break;
case OpeType.Separator: //正确
break;
}
}
#endregion
}
#endregion
}
#endregion
三、下面是表达式计算过程的主要步骤：
1、将字符串表达式中的数字、运算符、括号、逗号等提取出来，按顺序存储在一个动态数组中。
原理很简单，就是通过字符串搜索来实现，扫描字符串表达式，依次把运算符取出来放到动态数组中，运算符之间的内容就是参与运算的数了。
把字符串表达式转换成运算符、括号、逗号和数字的动态数组后，后面将处理这个数组，完成运算。
部分代码如下：
#region 将字符串表达式转换成运算因子(数字、常数及运算符)列表
/// <summary>
/// 将字符串表达式转换成运算因子列表
/// </summary>
/// <param name="str">字符串表达式</param>
private void ToList(List<CalVal> valList, string str)
{
do
{
//字符串中首个运算符的位置
int opePos = GetOpePos(str);
CalNum num = null;
CalOpe ope = null;
if (opePos > 0)//找到运算符且它前面有数字
{
num = GetNum(ref str, opePos);
}
else if (opePos == 0)//找到运算符且它在字符串最前面
{
ope = GetOpe(ref str);
}
else//没有找到运算符
{
num = GetNum(ref str);
}
if (num != null)
{
valList.Add(new CalVal(num));
}
if (ope != null)
{
valList.Add(new CalVal(ope));
}
} while (str != "");
}
#endregion
#region 获取字符串中首个运算符或常数的位置
/// <summary>
/// 获取字符串中首个运算符或常数的位置
/// </summary>
/// <param name="str">字符串</param>
/// <returns>值若为-1表示未找到</returns>
private int GetOpePos(string str)
{
CalOpeList opeList = new CalOpeList();
int pos = -1;
for (int i = 0; i < opeList.count; i++)
{
int k = -1;
int opeIndex = str.IndexOf(opeList.opeList[i].tag);
//科学计数法的情况：如果'+'或'-'的前面是'E'
if (opeList.opeList[i].opeType == OpeType.PlusOrMinus
&& opeIndex - 1 >= 0
&& str.Substring(opeIndex - 1, 1) == "E")
{
//从'+'或'-'的后面重新查找
k = str.Substring(opeIndex + 1).IndexOf(opeList.opeList[i].tag);
if (k != -1)//如果找到
{
//计算该运算符的位置
k += opeIndex + 1;
}
}
else
{
k = opeIndex;
}
if (pos == -1)
{
pos = k;
}
else if (k >= 0 && k < pos)
{
pos = k;
}
}
return pos;//值若为-1表示未找到
}
#endregion
#region 获得运算符
/// <summary>
/// 获得运算符
/// </summary>
private CalOpe GetOpe(ref string str)
{
CalOpeList opeList = new CalOpeList();
CalOpe ope = null;
for (int i = 0; i < opeList.count; i++)
{
if (str.IndexOf(opeList.opeList[i].tag) == 0)
{
ope = opeList.opeList[i];
//更新str
str = str.Substring(opeList.opeList[i].tag.Length);
break;
}
}
return ope;
}
#endregion
#region 获取数字
/// <summary>
/// 获取数字
/// </summary>
private CalNum GetNum(ref string str, int opePos)
{
CalNum result = null;
result = new CalNum(str.Substring(0, opePos));
//更新str
str = str.Substring(opePos);
return result;
}
/// <summary>
/// 获取数字
/// </summary>
private CalNum GetNum(ref string str)
{
CalNum result = null;
result = new CalNum(str);
//更新str
str = "";
return result;
}
#endregion
2、优先级的处理。
优先级的处理是表达式计算过程中的一个关键问题。
动态数组中的每个元素（运算符、分隔符或数字等）都有一个优先级，对存储表达式的动态数组从前往后扫描，遇到左括号，将运算符的优先级提升，遇到右括号的话，将运算符的优先级降低。这样处理过后，动态数组中的运算符的优先级各不相同，括号中的运算符的优先级就会高于括号外的运算符的优先级。比如括号外的加号的优先级低于括号内的加号的优先级，因为在处理的过程中把括号内的加号的优先级提升了。
/// <summary>
/// 优先级处理，提高括号中的算式的运算符的优先级
/// </summary>
private void LevelProcess()
{
int delLevel = 0;//优先级增量
for (int i = 0; i < valList.Count; i++)
{
if (valList[i].type == ValType.Operator)
{
//如果是左括号
if (valList[i].OpeType == OpeType.leftParenthesis)
{
delLevel += 1000;
continue;
}
//如果是右括号
if (valList[i].OpeType == OpeType.rightParenthesis)
{
delLevel -= 1000;
continue;
}
valList[i].level = valList[i].ope.level + delLevel;
}
}
}
3、在计算存储在动态数组中的表达式前，先生成优先级列表，并按优先级从高到低排好序。
#region 生成优先级列表
/// <summary>
/// 生成优先级列表
/// </summary>
private void MakeLevelList()
{
#region 生成优先级列表，优先级按从高到低存储
//逐个扫描运算因子，提取优先级列表，并按优先级从高到低存储
for (int i = 0; i < valList.Count; i++)
{
//如果是运算符
if (valList[i].type == ValType.Operator)
{
//如果是括号或分隔符
if (valList[i].OpeType == OpeType.leftParenthesis
|| valList[i].OpeType == OpeType.rightParenthesis
|| valList[i].OpeType == OpeType.Separator)
{
continue;
}
InsertIntoLevelList(ref levelList, valList[i].level);
}
}
#endregion
}
#endregion
#region 将优先级插入到优先级列表中
/// <summary>
/// 将优先级插入到优先级列表中
/// </summary>
/// <param name="levelList">优先级列表</param>
/// <param name="level">要插入的优先级</param>
private void InsertIntoLevelList(ref List<int> levelList, int level)
{
//列表为空的情况
if (levelList.Count == 0)
{
levelList.Add(level);
return;
}
//该优先级是否已存在
for (int i = 0; i < levelList.Count; i++)
{
//该优先级已存在
if (level == levelList[i])
{
return;
}
}
int k = 0;
for (; k < levelList.Count; k++)
{
if (level > levelList[k])
{
levelList.Insert(k, level);
break;
}
}
if (k >= levelList.Count)
{
levelList.Add(level);
}
}
#endregion
4、遍历优先级列表，按照优先级从高到低，扫描表达式动态数组，先计算优先级高的运算，用计算结果替换掉计算之前的运算符和参与运算的数。当把优先级列表中的优先级都处理完，对表达式的计算也就结束了，这时，表达式动态数组中将只剩下计算结果。
下面是计算过程的主要代码：
#region 核心算法，对于当前优先级，扫描运算因子列表并计算
if (levelList.Count != 0)//优先级列表不为空
{
#region 处理当前优先级
//对于当前优先级，逐个扫描运算因子，处理具有该优先级的运算
for (int i = 0; i < valList.Count; i++)
{
//找到具有该优先级的运算符
if (valList[i].type == ValType.Operator
&& valList[i].level == levelList[0])//该运算因子的优先级等于当前优先级
{
bool isSign = false;//Sign为true表示当前运算因子是正负号
currentPos = valList[i].primalPos;//记录当前运算因子在列表中的原始位置
//参数列表
List<CalNum> numList = new List<CalNum>();
//临时计算结果
CalNum num;
switch (valList[i].OpeType)//i表示该运算因子的位置
{
#region case OpeType.PlusOrMinus:
case OpeType.PlusOrMinus:
//若该运算符前面没有运算因子
//或前一个运算因子是运算符，则按正负号计算
if (i == 0 || (i - 1 >= 0 && valList[i - 1].type == ValType.Operator))
{
isSign = true;//是正负号
//获取该运算符的参数
if (i + 1 < valList.Count && valList[i + 1].type == ValType.Number)
{
//注意，下面第一句不可省略
numList = new List<CalNum>();
numList.Add(valList[i + 1].num);
}
//计算
num = CalOpeList.Calculate(valList[i].ope, numList);
//更新运算因子列表
ReplaceVal(num, 2, i);
//i无需调整
}
else//若前一个运算因子是操作数，则按加减号计算
{
//获取该运算符的参数
if (valList[i - 1].type == ValType.Number
&& i + 1 < valList.Count && valList[i + 1].type == ValType.Number)
{
//注意，下面第一句不可省略
numList = new List<CalNum>();
numList.Add(valList[i - 1].num);
numList.Add(valList[i + 1].num);
}
//计算
num = CalOpeList.Calculate(valList[i].ope, numList);
//更新运算因子列表
ReplaceVal(num, 3, i - 1);
//调整i
i--;
}
break;
#endregion
#region case OpeType.bothSides:
case OpeType.bothSides:
//获取该运算符的参数
if (i >= 1 && valList[i - 1].type == ValType.Number
&& i + 1 < valList.Count && valList[i + 1].type == ValType.Number)
{
//注意，下面第一句不可省略
numList = new List<CalNum>();
numList.Add(valList[i - 1].num);
numList.Add(valList[i + 1].num);
}
//计算
num = CalOpeList.Calculate(valList[i].ope, numList);
//更新运算因子列表
ReplaceVal(num, 3, i - 1);
//调整i
i--;
break;
#endregion
#region case OpeType.left:
case OpeType.left:
//获取该运算符的参数
if (i >= 1 && valList[i - 1].type == ValType.Number)
{
//注意，下面第一句不可省略
numList = new List<CalNum>();
numList.Add(valList[i - 1].num);
}
//计算
num = CalOpeList.Calculate(valList[i].ope, numList);
//更新运算因子列表
ReplaceVal(num, 2, i - 1);
//调整i
i--;
break;
#endregion
#region case OpeType.noParameter:
case OpeType.noParameter:
//注意，下面第一句不可省略
numList = new List<CalNum>();
//计算
num = CalOpeList.Calculate(valList[i].ope, numList);
//更新运算因子列表
ReplaceVal(num, 1, i);
break;
#endregion
#region case OpeType.right:
case OpeType.right:
#region 该运算符只有一个参数，且它的右边是常数
if (i + 1 < valList.Count
&& valList[i].ParameterNumber == 1
&& valList[i + 1].type == ValType.Number)
{
//获取该运算符的参数
//注意，下面第一句不可省略
numList = new List<CalNum>();
numList.Add(valList[i + 1].num);
//计算
num = CalOpeList.Calculate(valList[i].ope, numList);
//更新运算因子列表
ReplaceVal(num, 2, i);
}
#endregion
#region 该运算符不是只有一个参数，或者它的右边不是常数
else
{
//计算参数个数
int count = 0;
int k = i + 1;
//从运算符后面开始检测
//如果是左括号、分隔符或数字，则执行while中语句
while (k < valList.Count
&& (valList[k].type == ValType.Number
|| valList[k].OpeType == OpeType.Separator
|| valList[k].OpeType == OpeType.leftParenthesis))
{
//如果是数字，参数个数加1
if (valList[k].type == ValType.Number)
{
count++;
}
k++;
}
//注意，下面第一句不可省略
numList = new List<CalNum>();
//从该运算符后面，逐个扫描，获取该运算符的参数
//j表示已读取的参数个数
//m表示检测位置增量
int m = 0;
for (int j = 0; j < count; )
{
//如果找到数字，存为参数
if (valList[i + j + m + 1].type == ValType.Number)
{
numList.Add(valList[i + j + m + 1].num);
j++;
}
//如果是分隔符或左括号，检测位置增量加1，表示跳过该运算因子，继续检测
else if (valList[i + j + m + 1].OpeType == OpeType.Separator
|| valList[i + j + m + 1].OpeType == OpeType.leftParenthesis)
{
m++;
}
}
//计算
num = CalOpeList.Calculate(valList[i].ope, numList);
//更新运算因子列表，count+m+2中的2表示运算符本身和右括号
ReplaceVal(num, count + m + 2, i);
}
#endregion
break;
#endregion
}//end switch
if (!isSign)//如果不是正负号
{
break;//退出for循环
}
}
}
#endregion
#region 删除处理完的优先级
bool levelExists = false;//是否存在具有该优先级的运算符
//逐个扫描运算因子,判断是否仍存在具有该优先级的运算符
for (int i = 0; i < valList.Count; i++)
{
if (levelList[0] == valList[i].level)//存在
{
levelExists = true;
}
}
if (!levelExists)//该优先级已处理完则删除它
{
levelList.RemoveAt(0);
}
#endregion
}
#endregion
四、结束语。
没有什么高深的思想，我用最笨的办法实现了表达式计算。这个程序中用的最多的算法就是字符串查找，以及遍历数组。
程序截图：
源代码下载：点击下载
原文地址：http://www.cnblogs.com/s0611163/p/3504951.html