上周末参照书本写了个“计算器”的程序,其中最令我费解的就是“前序表达式”、“后续表达式”,好像记得老师在上课的时候讲过,估计当时也没听懂,看的稀里糊涂的,不过现在大概明白了……
在此仅做以笔记。
首先看下面所示表格:
中序表达式 | 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.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 ;
}
}
}
}
在上述处理中需要首先对输入的字符串进行处理,识别出运算符和操作数,另外在计算前序表达式结果的时候我并没有将其反转,而是直接参与了运算(计算的时候是从左往右计算的,参与运算的是反转的前序表达式,结果是一样的)。
参考书籍:《.NET 2.0 面向对象揭秘》