大张伟承认抄袭的歌曲:四则混合运算代码.......

CalUtility.cs

using System;
namespace Calculate
{
/// <summary>
/// CalUtility 的摘要说明。
/// 读算式辅助工具
/// </summary>

public class CalUtility
{
System.Text.StringBuilder StrB;
private int iCurr=0;
private int iCount=0;

/// <summary>
/// 构造方法
/// </summary>

public CalUtility(string calStr)
{
StrB = new System.Text.StringBuilder(calStr.Trim());
iCount = System.Text.Encoding.Default.GetByteCount(calStr.Trim());
}

/// <summary>
/// 取段，自动分析数值或计算符
/// </summary>
/// <returns></returns>

public string getItem()
{
//结束了
if(iCurr==iCount)
return "";
char ChTmp = StrB[iCurr];
bool b=IsNum(ChTmp);
if(!b)
{
iCurr++;
return ChTmp.ToString();
}
string strTmp="";
while(IsNum(ChTmp)==b && iCurr<iCount)
{
ChTmp = StrB[iCurr];
if(IsNum(ChTmp)==b)
strTmp +=ChTmp;
else
break;
iCurr++;
}
return strTmp;
}

/// <summary>
/// 是否是数字
/// </summary>
/// <param name="c">内容</param>
/// <returns></returns>

public bool IsNum(char c)
{
if((c>=’0’ && c<=’9’)|| c==’.’)
{
return true;
}
else
{
return false;
}
}

/// <summary>
/// 是否是数字
/// </summary>
/// <param name="c">内容</param>
/// <returns></returns>

public bool IsNum(string c)
{
if(c.Equals(""))
return false;
if((c[0]>=’0’ && c[0]<=’9’)|| c[0]==’.’)
{
return true;
}
else
{
return false;
}
}

/// <summary>
/// 比较str1和str2两个运算符的优先级，ture表示str1高于str2，false表示str1低于str2
/// </summary>
/// <param name="str1">计算符1</param>
/// <param name="str2">计算符2</param>
/// <returns></returns>

public bool Compare(string str1,string str2)
{
return getPriority(str1)>=getPriority(str2);
}

/// <summary>
/// 取得计算符号的优先级
/// </summary>
/// <param name="str">计算符</param>
/// <returns></returns>

public int getPriority(string str)
{
if(str.Equals(""))
{
return -1;
}
if(str.Equals("("))
{
return 0;
}
if(str.Equals("+")||str.Equals("-"))
{
return 1;
}
if(str.Equals("*")||str.Equals("/"))
{
return 2;
}
if(str.Equals(")"))
{
return 0;
}
return 0;
}
}
}

IOper.cs
using System;

namespace Calculate
{
/// <summary>
/// IOper 的摘要说明。
/// 计算符接口
/// </summary>

public interface IOper
{
/// <summary>
/// 计算符计算接口计算方法
/// </summary>
/// <param name="o1">参数1</param>
/// <param name="o2">参数2</param>
/// <returns></returns>
object Oper(object o1,object o2);
}
}

Opers.cs
using System;

namespace Calculate
{
/// <summary>
/// Opers 的摘要说明。
/// 各类计算符的接口实现，加减乘除
/// </summary>

public class OperAdd:IOper
{
public OperAdd()
{
//
// TODO: 在此处添加构造函数逻辑
//
}
#region IOper 成员

public object Oper(object o1, object o2)
{
Decimal d1 = Decimal.Parse(o1.ToString());
Decimal d2 = Decimal.Parse(o2.ToString());
return d1+d2;
}

#endregion
}

public class OperDec:IOper
{
public OperDec()
{
//
// TODO: 在此处添加构造函数逻辑
//
}
#region IOper 成员

public object Oper(object o1, object o2)
{
Decimal d1 = Decimal.Parse(o1.ToString());
Decimal d2 = Decimal.Parse(o2.ToString());
return d1-d2;
}
#endregion
}

public class OperRide:IOper
{
public OperRide()
{
//
// TODO: 在此处添加构造函数逻辑
//
}
#region IOper 成员

public object Oper(object o1, object o2)
{
Decimal d1 = Decimal.Parse(o1.ToString());
Decimal d2 = Decimal.Parse(o2.ToString());
return d1*d2;
}
#endregion
}

public class OperDiv:IOper
{
public OperDiv()
{
//
// TODO: 在此处添加构造函数逻辑
//
}
#region IOper 成员

public object Oper(object o1, object o2)
{
Decimal d1 = Decimal.Parse(o1.ToString());
Decimal d2 = Decimal.Parse(o2.ToString());
return d1/d2;
}

#endregion
}

}

OperFactory.cs
using System;

namespace Calculate
{
/// <summary>
/// OperFactory 的摘要说明。
/// 计算符接口工厂
/// </summary>
public class OperFactory
{
public OperFactory()
{
}
public IOper CreateOper(string Oper)
{
if(Oper.Equals("+"))
{
IOper p = new OperAdd();
return p;
}
if(Oper.Equals("-"))
{
IOper p = new OperDec();
return p;
}
if(Oper.Equals("*"))
{
IOper p = new OperRide();
return p;
}
if(Oper.Equals("/"))
{
IOper p = new OperDiv();
return p;
}
return null;
}
}
}

Calculate.cs
using System;
using System.Collections;

namespace Calculate
{
/// <summary>
/// Calculate 的摘要说明。
/// 计算实现主类
/// </summary>
public class Calculate
{
/// <summary>
/// 算术符栈
/// </summary>
private ArrayList HList;
/// <summary>
/// 数值栈
/// </summary>
public ArrayList Vlist;
/// <summary>
/// 读算试工具
/// </summary>
private CalUtility cu;
/// <summary>
/// 运算操作器工厂
/// </summary>
private OperFactory of;
/// <summary>
/// 构造方法
/// </summary>
/// <param name="str">算式</param>
public Calculate(string str)
{
//
// TODO: 在此处添加构造函数逻辑
//
HList = new ArrayList();
Vlist = new ArrayList();
of = new OperFactory();
cu = new CalUtility(str);
}

/// <summary>
/// 开始计算
/// </summary>

public object DoCal()
{
string strTmp=cu.getItem();
while(true)
{
if(cu.IsNum(strTmp))
{
//如果是数值，则写入数据栈
Vlist.Add(strTmp);
}
else
{
//数值
Cal(strTmp);
}
if(strTmp.Equals(""))
break;
strTmp=cu.getItem();
}
return Vlist[0];
}

/// <summary>
/// 计算
/// </summary>
/// <param name="str">计算符</param>

private void Cal(string str)
{
//符号表为空，而且当前符号为""，则认为已经计算完毕
if(str.Equals("")&&HList.Count==0)
return;
if(HList.Count>0)
{
//符号是否可以对消？
if(HList[HList.Count-1].ToString().Equals("(") && str.Equals(")"))
{
HList.RemoveAt(HList.Count-1);
if(HList.Count>0)
{
str=HList[HList.Count-1].ToString();
HList.RemoveAt(HList.Count-1);
Cal(str);
}
return;
}
//比较优先级
if(cu.Compare(HList[HList.Count-1].ToString(),str))
{
//如果优先，则计算
IOper p = of.CreateOper(HList[HList.Count -1].ToString());
if(p!=null)
{
Vlist[Vlist.Count -2] = p.Oper(Vlist[Vlist.Count-2],Vlist[Vlist.Count-1]);
HList.RemoveAt(HList.Count -1);
Vlist.RemoveAt(Vlist.Count -1);
Cal(str);
}
return;
}
if(!str.Equals(""))
HList.Add(str);
}
else
{
if(!str.Equals(""))
HList.Add(str);
}
}
}
}

本文是介绍使用Visual C#实现自动计算四则混合运算的一种方法，在.NET1.1框架中，还没有包含全现成的类，不过，现在经过我们下文的介绍，大家完全可以自己写一个，作用嘛，没什么，就是熟悉一下栈的用法，或者家里有上小学的，可以写一个程序给孩子练习一下四则混合运算也行，哈哈，废话不多说了，讲正题吧。

出一个典型的算术题： (6+2*5)/4

从题中，我们首先算 2*5=10 接下来算 6+10=16 最后算 16/4 =4 所以，结果是4

计算机怎么算？还好前辈给我们列出来一堆的算法，我们随便选一个就可以了。

第一种算法

使用栈来解决，意思就是把不优极最低的压到栈的最下面去，按照先进后出的原则，那么最优先级最低的就是最后计算了。

计算过程：

我们建立两个栈，一个是数据栈，一个是计算符号栈，以(6+2*5)/4为例子，看看倒底是怎么计算的。

假设：

1)优先级

符号之间的优先级如下：

“(“ “)” -1

“+”,”-” 0

“*”,”/” 1

数值越大，则越优先，同级别的比较时 先出现的优先。

2）将”(”,”)”设为特殊运算符，即单目运算，两邻两个运算符则可对消。

3) 计算条件

(1) 当前运算符不等于“”（特殊结束符）

(2) 运算符栈里的运行算个数>=1时

(3) 出栈口的运算符优先级高于将要入栈的运算符时或者两者可对消时。

计算时，则将符号出栈参与计算，数值栈的出栈口前两位元素出栈参与计算，计算结果值向数值栈压栈，并进行递归此操作。

图1：
1) “(” 压入符号栈 2 ) “6”压入数值栈

3) “（”与”+”比较优先级，认为”（”比”+”优先级低，则不满足计算条件，将”+”压入符号栈.

图2：
1) 将”2” 压入数值栈。

2) 将”*”与”+”比较优先级，算得”+”优先级低于”*”，则不满足计算条件，将”*”压入符号栈。

图3：
1) 将 “5”压入数植栈。 2) 将“*“与”)”比较优先级，得出”*”比”)”优先级要高。进行计算，将”*”出栈、”5”、”2”出栈，参与计算

图4：
1) 将 2*5 =10的结果压入数值栈。

2) （递归）比较 “+”与”)”优先级，得出”+”比”)”优先级要高。再进行计算，将”+”出栈、”10”、”6”出栈，参与计算。

图 5：
1) 将 6+10 =16的结果压入数值栈。

2) （递归）比较 “)”与”(”优先级，得出两者可以对消，将”(”符号出栈，与”)”对消，继续取下一个符号。

图6：
1) 将”/”入符号栈。

2）将”4”入数值栈。

3) 发现””算式结束符，则进行计算, 将 “/”、”4’、”16”出栈，参与计算。

图7：
1) 将计算结果压入数值栈。

成功了! 辛苦的计算工作终于干完了，看起来比人脑计算复杂多了：）

第二种算法

第二种方法，我们简单的提一下，在这里不作详细过程的叙述。第二种，就是使用树的方式，将一个算式组织成一定规律的树，之后，再进行遍历计算即得得到结果。还是以上面的算式作例子，最终形成的树的样式：（注意“()”这个符号要特殊处理）

图8：
使用树的深度遍历即可算出最终的结果。

上面的不要吓人了
怎么这么多