通过前缀表达式计算中缀表达式

通过前缀表达式计算中缀表达式

         之前我们有讨论《中缀表达式转换为前缀表达式》和《前缀表达式的计算》，通过这两部分，我们可以先将一个中缀表达式转换为前缀表达式，进而利用前缀表达式的计算方法得到前缀表达式的值，也就是中缀表达式的值。

         在《中缀表达式转换为前缀表达式》中，我们对中缀表达式的输入是用空白符间隔的，这样对于用户的输入有很大的限制性。我们最理想的情况是用户既可以输入空白符也可以不输入，即根据个人喜好自由输入。典型的方法就是对输入的表示中缀表达式的字符串进行词法分析，解析出对应的中缀表达式，进而进行转换操作和计算。关于中缀表达式的词法分析，我们可以参考《四则运算的词法分析》。

         本文我们是将上面提到的三部分进行整合，用户输入一个字符串，我们首先通过词法分析解析出对应的中缀表达式，然后将中缀表达式转换为前缀表达式，进而对前缀表达式进行计算得到输入的中缀表达式的值。

         具体程序如下：

// 通过前缀表达式计算中缀表达式，词法分析

#include <iostream>

#include <sstream>

#include <vector>

#include <string>

#include <map>

#include <stack>

using namespace std;



// 加入词法分析 BEGIN

struct TI

{

    string token;

    int    id;

};



bool is_blank(char ch)

{

    return ch == ' ' || ch == '    ';

}



void get_exp(string& exp)

{

    getline(cin, exp);

}



// token及其编码

void init_keys(map<string, int>& keys)

{

    keys.clear();

    keys["+"] = 1;

    keys["-"] = 2;

    keys["*"] = 3;

    keys["/"] = 4;

    keys["("] = 5;

    keys[")"] = 6;

    keys["__NUM__"] = 7;

}



void lex(const string& exp, vector<TI>& to_id, const map<string, int>& keys)

{

    to_id.clear();

    char ch;

    for (string::size_type pos = 0; pos < exp.size(); /* ++pos */)

    {

        TI ti;

        ch = exp[pos];



        if (is_blank(ch))

        {

            ++pos;

            continue;

        }

        if (ch >= '0' && ch <= '9' || ch == '.')

        {

            ti.token += ch;

            ++pos;

            if (pos >= exp.size())

            {

                ti.id = keys.size();

                to_id.push_back(ti);

                return;

            }

            ch = exp[pos];

            while (ch >= '0' && ch <= '9' || ch == '.')

            {

                ti.token += ch;

                ++pos;

                if (pos >= exp.size())

                {

                    ti.id = keys.size();

                    to_id.push_back(ti);

                    return;

                }

                ch = exp[pos];

            }

            ti.id = keys.size();

            to_id.push_back(ti);

        }

        else

        {

            map<string, int>::const_iterator cit;

            switch (ch)

            {

            case '+':

            case '-':

            case '*':

            case '/':

            case '(':

            case ')':

                ti.token += ch;

                cit = keys.find(ti.token);

                if (cit == keys.end())

                {

                    cout << "test" << endl;

                }

                ti.id = cit->second;

                to_id.push_back(ti);

                ++pos;

                break;



            default:

                // ti.token += string("Unknown:") + ch;

                ti.token += string("未知字符：") + ch;

                ti.id = -1;

                to_id.push_back(ti);

                ++pos;

                break;

            }

        }

    }

}



// 基于词法分析读取中缀表达式

void get_infix_lex(vector<string>&inf, const map<string, int>& keys)

{

    inf.clear();

    string line;

    getline(cin, line);

    vector<TI> to_id;

    lex(line, to_id, keys);

    for (vector<TI>::size_type i = 0; i != to_id.size(); ++i)

    {

        inf.push_back(to_id[i].token);

    }

}



// 加入词法分析 END





// 中缀转前缀 BEGIN

// 通过空白符进行间隔

void GetInfix(vector<string>& infix)

{

    infix.clear();

    string line;

    getline(cin, line);



    istringstream sin(line);

    string tmp;

    while (sin >> tmp)

    {

        infix.push_back(tmp);

    }

}



// 初始化操作符

void InitOperators(map<string, int>& opers)

{

    opers.clear();

    opers["("] = 100;

    opers[")"] = 900;

    opers["+"] = 100;

    opers["-"] = 100;

    opers["*"] = 200;

    opers["/"] = 200;

}



bool IsOperator(const string& op, const map<string, int>& opers)

{

    auto cit = opers.find(op);

    if (cit != opers.end())

    {

        return true;

    }

    else

    {

        return false;

    }

}



void InfixToPrefix(const vector<string>& infix, vector<string>& prefix, map<string, int>& opers)

{

    prefix.clear();

    stack<string> stk; // 操作符栈

    for (int i = infix.size() - 1; i >= 0; --i) // 从右到左扫描

    {

        if (!IsOperator(infix[i], opers)) // 如果是操作数

        {

            prefix.push_back(infix[i]);

        }

        else // 如果是操作符

        {

            if (infix[i] == ")") // 如果是右括号，则直接入栈

            {

                stk.push(infix[i]);

            }

            else if (infix[i] == "(") // 如果是左括号

            {

                // 依次弹出栈中的操作符，直至遇到右括号

                while (!stk.empty())

                {

                    if (stk.top() == ")")

                    {

                        stk.pop();

                        break;

                    }

                    else

                    {

                        prefix.push_back(stk.top());

                        stk.pop();

                    }

                }

            }

            else // 如果是其他操作符

            {

                while (!stk.empty() && stk.top() != ")" && opers[stk.top()] > opers[infix[i]]) // 栈顶操作符优先级大于当前操作符优先级

                {

                    prefix.push_back(stk.top());

                    stk.pop();

                }

                // 将当前操作符入栈

                stk.push(infix[i]);

            }

        }

    }



    // 检测操作符栈是否为空

    while (!stk.empty())

    {

        prefix.push_back(stk.top());

        stk.pop();

    }

    // 将prefix翻转

    reverse(prefix.begin(), prefix.end());

    return;

}



void Display(const vector<string>& fix)

{

    for (auto i = 0; i != fix.size(); ++i)

    {

        cout << fix[i] << ' ';

    }

    cout << endl;

}



// 中缀转前缀 END





// 前缀的计算 BEGIN

// 读取前缀表达式

void GetPrefix(vector<string>& prefix)

{

    prefix.clear();

    string line, tmp;

    getline(cin, line);

    istringstream sin(line);

    while (sin >> tmp)

    {

        prefix.push_back(tmp);

    }

}



// 将IsOperator重载，单参数

bool IsOperator(const string& op)

{

    return op == "+" || op == "-" || op == "*" || op == "/";

}



double CalPrefix(const vector<string>& prefix)

{

    double ret = 0.0;

    stack<double> opeStk;

    for (int i = prefix.size() - 1; i >= 0; --i)

    {

        if (!IsOperator(prefix[i]))

        {

            opeStk.push((double)atof(prefix[i].c_str()));

        }

        else

        {

            double a = opeStk.top();

            opeStk.pop();

            double b = opeStk.top();

            opeStk.pop();

            double c = 0.0;



            switch (prefix[i][0])

            {

            case '+':

                c = a + b;

                opeStk.push(c);

                break;



            case '-':

                c = a - b;

                opeStk.push(c);

                break;



            case '*':

                c = a * b;

                opeStk.push(c);

                break;



            case '/':

                c = a / b;

                opeStk.push(c);

                break;



            default:

                break;

            }

        }

    }



    if (opeStk.size() == 1)

    {

        return opeStk.top();

    }

    else

    {

        return -1000000000.0;

    }

}

// 前缀的计算 END



int main()

{

    map<string, int> keys; // 用于词法分析

    init_keys(keys);



    map<string, int> opers; // 操作符及其优先级

    InitOperators(opers);



    vector<string> infix;

    vector<string> prefix;

    

    while (true)

    {

        get_infix_lex(infix, keys);



        InfixToPrefix(infix, prefix, opers);

        Display(prefix);



        cout << CalPrefix(prefix) << endl;

        cout << endl;

    }

    return 0;

}

         在程序中几个重要的函数：

         lex：对字符串进行词法分析

         InfixToPrefix：中缀转后缀

         CalPrefix：前缀的计算

 

         目前关于四则运算方面的讨论系列，我们已经讨论了以下议题：

•          后缀表达式的计算
•          中缀转后缀
•          通过后缀表达式计算中缀表达式
•          前缀表达式的计算
•          中缀转前缀
•          通过前缀表达式计算中缀表达式
•          对输入的字符串进行空白符的预处理
•          对输入的字符串进行词法分析得到相应的中缀表达式
•          对于代数表达式的词法分析、转换、计算
•          后缀表达式转换中缀表达式的三个层次的讨论
•          检测中缀表达式的合法性，转换、计算两个过程的错误处理机制

 

         对于四则运算方面的讨论我们暂时告一段落，以后会根据想法再有所补充。