华为OJ—四则运算

题目如下：

描述:
请实现如下接口
    /* 功能：四则运算
     * 输入：strExpression：字符串格式的算术表达式，如: "3+2*{1+2*[-4/(8-6)+7]}"
         * 返回：算术表达式的计算结果
     */
    public static int calculate(String strExpression)
    {
        /* 请实现*/
        return 0;
    } 
约束：
pucExpression字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。
pucExpression算术表达式的有效性由调用者保证; 
 
知识点 栈
运行时间限制 10M
内存限制 128
输入
输入一个算术表达式
输出
得到计算结果
样例输入 3+2*{1+2*[-4/(8-6)+7]}
样例输出 25

解答要点：

1、需要将中缀表达式转换为后缀表达式后，然后按顺序进行计算;

2、需要注意数值可能出现负数。

代码

#include<string>
#include<stack>
#include<vector>
#include<iostream>
#include<sstream>

using namespace std;

// 四则运算，
//获得优先级
int getPriorty(char &c)
{
    switch(c)
    {
    case '{':
    case '[':
    case '(':
        return -1;
    case '+':
    case '-':
        return 0;
    case '*':
    case '/':
        return 1;
    case '}':
        return 2;
    case ']':
        return 3;
    case ')':
        return 4;
    }
}

//元素类，表示表达式中的一个元素（数值或者运算符），因为可能存在负数，故此处需要进行封装
typedef struct ELEMENT
{
    unsigned _type;            //元素类型，0表示元素，1表示运算符，-1表示无效
    int _value;                     //数值
    char _c_operation;        //运算符
    int _priority;                  //运算符优先级

    ELEMENT()
    {
        _type=-1;
    };

    ELEMENT(int value)
    {
        _type=0;
        _value=value;
    };

    ELEMENT(char c)
    {
        _type=1;
        _c_operation=c;
    }

    //打印输出
    static void print(vector<ELEMENT> datas)
    {
        for(size_t i=0; i<datas.size(); i++)
        {
            if(datas[i]._type==-1)
                continue;
            else if(datas[i]._type==0)
            {
                if(datas[i]._value<0)
                    cout<<"("<<datas[i]._value<<")";
                else
                    cout<<datas[i]._value;
                continue;
            }
            else if(datas[i]._type==1)
            {
                cout<<datas[i]._c_operation;
                continue;
            }
        }
        cout<<endl;
    }

    //将结构转化为字符串
    static void elements2string(vector<ELEMENT> &datas,string &strResult)
    {
        ostringstream out;
        for(size_t i=0; i<datas.size(); i++)
        {
            if(datas[i]._type==-1)
                continue;
            else if(datas[i]._type==0)
            {
                if(datas[i]._value<0)
                    out<<"("<<datas[i]._value<<")";
                else
                    out<<datas[i]._value;
                continue;
            }
            else if(datas[i]._type==1)
            {
                out<<datas[i]._c_operation;
                continue;
            }
        }
        strResult=out.str();
    }
} Element;

//string 转int
inline int string2int(string &str)
{
    istringstream sitemp(str);
    int temp;
    sitemp>>temp;
    return temp;
}

//中缀表达式转后缀表达式
//读入表达式，如果是数字则入队(element)
//如果是运算符，比较运算符与栈顶运算符的优先级，如果栈顶运算符的优先级大于等于当前运算符，则将栈顶运算符出栈入队直到栈顶运算符优先级小于等于
//          当前运算符为止,然后将当前运算符入栈;否则当前运算符直接入栈
//          “{}”“（）”的优先级是最高的，“{”或“（”只有在遇到“}”“）”才出栈
void infix2postfixEx(string &strInFix, vector<Element> &elements)
{
    stack<char> stOperation;    //运算符栈
    for(size_t i=0; i<strInFix.length(); i++)
    {
        char c=strInFix[i];
        if(c<'0'||c>'9')//如果是运算符
        {
            if(c=='-')//如果运算符是'-',其有可能是负号标志，也有可能是减号
            {
                if(i==0||
                        strInFix[i-1]=='{'||strInFix[i-1]=='['||strInFix[i-1]=='('||strInFix[i-1]=='*'||strInFix[i-1]=='/'||
                        strInFix[i-1]=='+'||strInFix[i-1]=='-') //如果'-'是第一位或者'-'前面是*,/,{,[,(,+,- 。说明该'-'表示的是负号;否则表示正常的运算符
                {
                    string str=string(1,c)+strInFix[++i];
                    int temp=string2int(str);
                    elements.push_back(Element(temp));
                    continue;
                }
            }

            if(stOperation.empty())
                stOperation.push(c);
            else
            {
                if(c=='{'||c=='['||c=='(')
                {
                    stOperation.push(c);
                    continue;
                }
                else if(c==')')
                {
                    while(stOperation.top()!='(')
                    {
                        elements.push_back(Element(stOperation.top()));
                        stOperation.pop();
                    }
                    stOperation.pop();
                    continue;
                }
                else if(c=='}')
                {
                    while(stOperation.top()!='{')
                    {
                        elements.push_back(Element(stOperation.top()));
                        stOperation.pop();
                    }
                    stOperation.pop();
                    continue;
                }
                else if(c==']')
                {
                    while(stOperation.top()!='[')
                    {
                        elements.push_back(Element(stOperation.top()));
                        stOperation.pop();
                    }
                    stOperation.pop(); //弹出'['
                    continue;
                }

                if(getPriorty(stOperation.top())<getPriorty(c))     //栈顶运算符优先级小于当前运算符，则将当前运算符入栈
                    stOperation.push(c);
                else//栈顶运算符优先级大于等于当前运算符，则将栈顶运算符出栈入队，直到栈顶运算符优先级小于当前运算符为止
                {
                    while(!stOperation.empty()&&getPriorty(stOperation.top())>=getPriorty(c))
                    {
                        elements.push_back(Element(stOperation.top()));
                        stOperation.pop();
                    }
                    stOperation.push(c);
                }
            }
        }
        else  //如果是数字，则直接入队
        {
            string str=string(1,c);
            int temp=string2int(str);
            elements.push_back(Element(temp));
        }
    }
    while(!stOperation.empty())
    {
        elements.push_back(Element(stOperation.top()));
        stOperation.pop();
    }
    //Element::print(elements);
}

void calculate(string &strInFix,string &strOutResult){

    vector<Element> elements;//后缀表达式
    infix2postfixEx(strInFix,elements);

    //根据后缀表达式进行计算
    stack<int> datas;
    for(auto &t:elements){
        if(t._type==0)
            datas.push(t._value);
        else if(t._type==1){
            auto t1=datas.top();
            datas.pop();
            auto t2=datas.top();
            datas.pop();
            if(t._c_operation=='+')
                 datas.push(t2+t1);
            else if(t._c_operation=='-')
                datas.push(t2-t1);
            else if(t._c_operation=='*')
                datas.push(t2*t1);
            else if(t._c_operation='/')
                datas.push(t2/t1);
        }
    }

    ostringstream    out;
    out<<datas.top();
    strOutResult=out.str();
}

int main()
{
    string str,strPostFix;
    getline(cin,str);
    calculate(str,strPostFix);
    cout<<strPostFix;
}