数据结构多项式计算器（将中缀表达式转化为后缀表达式实现）

　　数据结构习题-多项式计算器（将中缀表达式转化为后缀表达式实现）

　　我们把平时所用的标准四则运算表达式，即“9+（3-1）×3+10÷2”叫做中缀表达式。“9 3 1 - 3 × + 10 2 ÷ +”叫做后缀表达式。

　　后缀表达式的计算规则为：有一个栈，先从左到右遍历表达式的每个数字和运算符，遇到数字就进栈，遇到符号就将处于栈顶两个数字出栈，进行运算，运算结果出栈，一直到最终获得结果。

　　中缀表达式“9+（3-1）×3+10÷2”转化为后缀表达式“9 3 1 - 3 × + 10 2 ÷ +”

　　规则为：从左到右遍历中缀表达式的每个数字与符号，如果是数字则直接输出，即成为后缀表达式的一部分，如果是符号则分两种情况，是右括号则将栈内左括号（含左括号）的元素出栈，不是右括号则判断二者的优先级，若优先级低于栈顶元素，则将不低于当前符号优先级的栈顶符号元素依次出栈并输出，最后将当前符号进栈，一直到完成对中缀表达式的遍历为止。

　　以下为实现代码：

#ifndef CAL_HEAD_H_
#define CAL_HEAD_H_


#include <iostream>
#include<string>
#include<stack>
#include<stdlib.h>
using namespace std;

class Calculater
{
private:
    string str;             //  存放中缀表达式的字符串
    string temp_str[100];
    stack<double> suffix;   // 存放后缀表达式的栈
    stack<char> temp;      // 临时存放运算符的栈
    public:
    Calculater(string InfixExp = NULL):str(InfixExp){}   // 构造函数
    ~Calculater(){}

    bool infixToSuffix();   // 将中缀表达式转化为后缀表达式
    double calsuffix();       // 计算后缀表达式
    double cal(double num1,double num2, const char* op);  // 计算
};

bool Calculater::infixToSuffix()
{
    char temp_2 = ' ';    // 存放临时元素
    int sign = 0;
    for (int i = 0; i < str.length(); ++i)
    {
        // 如果是数字，则直接压入临时字符串
        while(str[i]>='0' && str[i]<='9')
        {
            temp_str[sign] += str[i++];
            //suffix.push(str[i]);
        }
        if (temp_str[sign] != "")
        {
            sign++;
        }
        // 如果是（或者加减乘除运算符，则压入临时栈
        if (str[i]=='(' ||str[i]=='+' ||
                str[i]=='-' || str[i]=='/' || 
                str[i]=='*' || str[i]==')')
        {
            
            // 如果临时栈为空，则元素直接入栈
            if (temp.empty())
            {
                //temp_str += str[i];
                temp.push(str[i]);
            }
            else
            { 
                // 如果不为空，若栈顶元素为（，则元素直接入栈
                temp_2 = temp.top();
                //temp.top(temp_2);
                if (str[i] == '(')
                {
                    //temp_str += str[i];
                    temp.push(str[i]);
                }
                else
                {
                    // 若栈顶元素不为‘（’，是右括号或优先级低于栈顶元素，则栈顶元素依次出栈并输出
                    if (str[i] == ')')
                    {
                        temp_2 = temp.top();  // 返回栈顶元素
                        temp.pop();           // 删除栈顶元素
                        while(temp_2 != '(')
                        {
                            temp_str[sign++] = temp_2;
                            //suffix.push(temp_2); // 将取出的运算符压入临时字符串
                            temp_2 = temp.top();  // 返回栈顶元素
                            temp.pop();           // 删除栈顶元素
                        }
                        //temp.push(str[i]);
                        temp_2 = NULL;
                    }
                    else if ((temp_2=='*'||temp_2=='/') && (str[i]=='+'||str[i]=='-'))
                    {
                        
                        while(temp_2 != '(')
                        {
                            temp_str[sign++] = temp_2;
                            //suffix.push(temp_2); // 将取出的运算符压入临时字符串
                            temp.pop();    // 再取出临时栈的栈顶元素
                            temp_2 = temp.top();
                        }
                        temp.push(str[i]);   // 将当前运算符入栈                        
                    }
                    else 
                    {
                        temp.push(str[i]);   // 将当前运算符入栈
                    }
                }
            }
        }
        else
        {
            return false;
        }
    }
    // 遍历整个运算式后 ，如果临时栈不为空，则元素出栈入临时字符串
    while (!temp.empty())
    {
        temp_2 = temp.top();  // 返回栈顶元素
        temp.pop();           // 删除栈顶元素
        //suffix.push(temp_2);
        temp_str[sign++] = temp_2;
    }
}

double Calculater::cal(double num1 , double num2 ,const char* op)
{
    switch(op[0])
    {
    case '+':
            return num1 + num2;
    case '-':
             return num1 - num2;
    case '*':
             return num1 * num2;
    case '/':
    {
        if (num2 == 0)
        {
            cout<<"ERROR!"<<endl;
        }
        return num1;
    }
    default:
        cout<<"ERROR!"<<endl;
    }
}

double Calculater::calsuffix()
{
    double num1, num2;
    for (int i = 0; temp_str[i]!=""; ++i)
    {
        if (temp_str[i]!="+" && temp_str[i]!="-" &&
            temp_str[i]!="*" && temp_str[i]!="/")
        {
            //cout<<temp_str[i]<<endl;

            num1 = atof(temp_str[i].c_str());

            //cout<<num1<<endl;
            suffix.push(num1);
        }
        else
        {
            num2 = suffix.top();
            suffix.pop();
            num1 = suffix.top();
            suffix.pop();
            num1 = cal(num1, num2, temp_str[i].c_str());
            suffix.push(num1);
        }
    }
    num1 = suffix.top();
    
    

    return num1;
}

#endif

　　该头文件只是简单实现了表达式的转化过程，没有报错系统。学报错系统时，可以直接从中缀表达式入手或者从将中缀表达式转化后缀表达式的遍历运算符的过程中入手。