四则混合运算C++代码（中缀表达式）

在复习算法的时候，栈的应用举例中有一项就是计算中缀表达式的四则混合运算。根据算法自己写了一下程序。

1、程序分为两块，一部分中缀转成后缀，一部分计算后缀。其中使用到了堆栈，我自己做了一个简单地模板栈。

2、中缀转后缀的程序，接受一个内涵中缀表达式的string，输出的是一个后缀表达式的string。中缀表达式的字符串校验自行解决，程序不负责。因为数字都是以字符的形式存在，因此一个完整的数字后面用一个“；”作为标识，以便计算式可以完整识别一个数字。

例如：输入"90+（3-1）*3+10/2 ”输出即为“90；3；1；- 3；*+10；2；/+”

3、计算后缀表达式的结果程序，接受一个后缀表达式的string，循环读取其中每一个字符，如果是数字即放到字符串strNum之中，直到遇到“；”即将strNum中记录的完整数字的字符串转换成浮点类型，使用std::atof()函数，然后入栈。遇到符号即取出栈顶两个元素计算，结果入栈。最后栈里的唯一数字即结果，return。

首先中缀表达式转换成后缀表达式：

///2月28日中缀表达式转换成后缀表达式
//输入中缀表达式字符串infix，转化后返回后缀表达式字符串postfix
//输出串中，每一个数字后面放置一个；作为标识。因为数字使用char表达，234即三个char，“；”标识数字结束。做好数字完结标识后，即写入输出字符串中。
//遇到符号，左括号直接入栈；右括号时，将栈顶符号逐个取出写入输出字符串中，直到遇见左括号；
//运算符需循环与栈顶符号优先级进行比较：如果小于或者等于，取出栈顶符号写入输出字符串中，如果是左括号，直接入栈，如果优先级高于栈顶符号，入栈。
std::string InfixToPostfix(std::string infix)
{
char current = 0;//读入的字符
std::string postfix;//写入后缀表达式的字符串

SqStack<char> mark;//符号入栈
InitStack(&mark);

std::map<char,int> priority;//运算符号优先级表
priority['+'] = 0;
priority['-'] = 0;
priority['*'] = 1;
priority['/'] = 1;

for(int i = 0;i<infix.length();++i)//逐个读取中缀表达式字符串中的字符
{
current =infix[i];
switch(current)
{
case '0':case '1':case '2':case '3':case '4':case '5':
case '6':case '7':case '8':case '9':case '.':
postfix.push_back(current);//如果是数字的话直接写入输出字符串。
break;
case '+':case '-':case '*':case '/':
if(infix[i-1] != ')') postfix.push_back(';');//如果运算符的前一项不是右括号即说明前一个数字输入完毕，用；标识前面几个字符组成一个数字。
if(!IsEmpty(mark))//如果符号栈非空，即比较目前符号与栈顶符号优先级，低于等于出栈，并写入输出字符串。
{
char tempTop;
GetTop(mark,tempTop);
while(tempTop != '(' && priority[current]<=priority[tempTop])
{
char tempOut;
Pop(&mark,&tempOut);
postfix.push_back(tempOut);
if(IsEmpty(mark))//如果栈为空，跳出while循环
break;
GetTop(mark,tempTop);
}
}
Push(&mark,current);//符号全部出栈或者遇到了'('或者大于栈顶符号的优先级，将新符号压入栈中。
break;
case '(':
Push(&mark,current);//左括号直接入栈
break;
case ')':
postfix.push_back(';');//右括号说明前方数字输入完成，标识一下。
char tempTop;
GetTop(mark,tempTop);
while(tempTop !='(')//直到栈顶元素是左括号才停止循环
{
char tempOut;
Pop(&mark,&tempOut);
postfix.push_back(tempOut);//出栈并写入输出字符串中。
GetTop(mark,tempTop);
}
char tempOut;
Pop(&mark,&tempOut);//直接将左括号出栈。
break;
default:
break;//忽略其他字符。
}
}
if(infix[infix.size()-1] != ')') postfix.push_back(';');//中缀表达式最后一个是数字需要加上；标识其是一个数字的结束，便于计算时统一识别数字结束。
while(!IsEmpty(mark))//如果栈非空，全部出栈并写入输出字符串。
{
char tempOut;
Pop(&mark,&tempOut);
postfix.push_back(tempOut);
}
return postfix;//返回后缀表达式。
}

然后计算后缀表达式：

///计算后缀表达式结果
//输入为后缀表达式s，逐个读取字符，如果是数字即放入存放当前数字的字符串中，遇到“；”即将此字符串转换为float，
//使用std::atof()，参数接受const char*类型，字符串需使用.c_str()转化。
//完成数字识别转化后入栈，遇到符号即取出栈顶的两个数字计算，结果入栈。
//栈中最后的元素即为结果。
float Compute(std::string s)
{
SqStack<float> waitForCompute;
SqStack<float>* ptWait = &waitForCompute;
InitStack<float>(ptWait);         //使用栈记录等待计算的数

std::string strNum;
float currNum = 0;

float temNum1 = 0;
float temNum2 = 0;
for(std::string::const_iterator i = s.begin();i<s.end();++i)
{
switch(*i)
{
case '0':case '1':case '2':case '3':case '4':case '5':
case '6':case '7':case '8':case '9':case '.':
strNum.push_back(*i);
break;
case '+':
Pop(ptWait,&temNum1);
Pop(ptWait,&temNum2);
Push(ptWait, temNum2 + temNum1);
break;
case '-':
Pop(ptWait,&temNum1);
Pop(ptWait,&temNum2);
Push(ptWait, temNum2 - temNum1);
break;
case '*':
Pop(ptWait,&temNum1);
Pop(ptWait,&temNum2);
Push(ptWait, temNum2 * temNum1);
break;
case '/':
Pop(ptWait,&temNum1);
Pop(ptWait,&temNum2);
Push(ptWait, temNum2 / temNum1);
break;
case ';':
currNum = std::atof(strNum.c_str());//字符串转换为浮点型。
strNum.clear();
Push(ptWait,currNum);
break;
}
}
Pop(ptWait,&currNum);
return currNum;

}

其中使用到了自定义的一个顺序栈：

const int MAXSIZE = 50;

template<class T> struct SqStack
{
T data[MAXSIZE];
int top;
};

template<class T> void InitStack(SqStack<T>* s);

template<class T>  void DestroyStack(SqStack<T>* s);

template<class T>  void ClearStack(SqStack<T>* s);

template<class T>  bool IsEmpty(SqStack<T> s);

template<class T>  void GetTop(SqStack<T> s,T& e);

template<class T>  void Push(SqStack<T>* s,T e);

template<class T>  void Pop(SqStack<T>* s, T* e);

template<class T>  int StackLength(SqStack<T> s);