代数表达式的四则运算

代数表达式的四则运算

         前面我们讨论了四则运算的相关情形，对于给定的中缀表达式，我们对其进行词法分析、中缀转后缀、后缀计算等过程，最终得到中缀表达式的值。

         在我们输入的中缀表达式中，我们对于每个操作数都是已知的值，不存在未知量。

         而在本文中，我们是重点讨论有关中缀表达式中存在未知量的情形，我们将含有未知量的表达式称作为代数表达式。

         比如给定一代数表达式：

a+b-c/d*xyz

         该表达式中存在5个未知量：a、b、c、d以及xyz。我们的处理过程还是按照以前处理四则运算的情形那样，首先对输入的代数表达式进行词法分析，得到想要的操作符、已知量、未知量等。然后将中缀表达式转换为后缀表达式，最后在进行后缀表达式计算的时候，我们需要知道未知量实际的值是多少，这就需要我们对未知量指定特定的数值，最终得到代数表达式的结果。

         从上面可以看出，我们的计算过程还是分为三个步骤，只是在第三个步骤计算后缀表达式的时候，我们需要对未知量指定特定的值。

         一、词法分析

         代数表达式中的token可以分为三种：

         1.操作符：+、-、*、/、(、)

         2.已知量：常数

         3.未知量：开头为字母，后面可以为字母或数字

         我们对token检测并存放到相应的中缀表达式中，这里没有必要对token设置其对应的种类码。

         二、中缀转后缀

         具体算法流程可以参照以前的，关键是要设置一个操作符栈。

         三、后缀的计算

         设置一个操作数栈，对于未知量需要指定其特定数值。

 

         多说无益，下面我们给出代数表达式四则运算的程序：

// 代数表达式的四则运算
#include <iostream>
#include <vector>
#include <map>
#include <stack>
#include <string>
#include <cctype>
#include <cassert>
using namespace std;

bool is_blank(char ch)
{
    return ch == ' ' || ch == '    ' || ch == '\n';
}

void lexer(const string& algexp, vector<string>& infix)
{
    infix.clear();
    char ch;
    for (auto i = 0; i < algexp.size(); /*++i*/)
    {
        if (is_blank(algexp[i]))
        {
            ++i;
            continue;
        }

        string token;
        ch = algexp[i];
        if (isalpha(ch)) // 未知量
        {
            token += ch;
            ++i;
            if (i >= algexp.size()) // 扫描结束
            {
                infix.push_back(token);
                return;
            }
            ch = algexp[i];
            while (isalnum(ch))
            {
                token += ch;
                ++i;
                if (i >= algexp.size()) // 扫描结束
                {
                    infix.push_back(token);
                    return;
                }
                ch = algexp[i];
            }
            infix.push_back(token);
        }
        else if (isdigit(ch))
        {
            token += ch;
            ++i;
            if (i >= algexp.size()) // 扫描结束
            {
                infix.push_back(token);
                return;
            }
            ch = algexp[i];
            while (isdigit(ch))
            {
                token += ch;
                ++i;
                if (i >= algexp.size()) // 扫描结束
                {
                    infix.push_back(token);
                    return;
                }
                ch = algexp[i];
            }
            infix.push_back(token);
        }
        else
        {
            switch (ch)
            {
            case '+':
            case '-':
            case '*':
            case '/':
            case '(':
            case ')':
                token += ch;
                infix.push_back(token);
                ++i;
                break;

            default:
                ++i;
                break;
            }
        }
    }
}

bool is_operator(const string& str, const map<string, int>& optors)
{
    auto cit = optors.find(str);
    if (cit != optors.end())
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool is_uncertain(const string& str)
{
    assert(!str.empty());
    if (isalpha(str[0]))
    {
        return true;
    }
    else
    {
        return false;
    }
}

void in_to_post(const vector<string>& infix, vector<string>& postfix, map<string, double>& unk_num, map<string, int>& optors)
{
    postfix.clear();
    unk_num.clear();
    stack<string> op_st;
    for (auto i = 0; i < infix.size(); ++i)
    {
        if (!is_operator(infix[i], optors))
        {
            postfix.push_back(infix[i]);
            if (is_uncertain(infix[i]))
            {
                unk_num[infix[i]] = 0.0;
            }
        }
        else
        {
            if (infix[i] == "(")
            {
                op_st.push(infix[i]);
            }
            else if (infix[i] == ")")
            {
                while (!op_st.empty())
                {
                    string tmp = op_st.top();
                    if (tmp == "(")
                    {
                        op_st.pop();
                        break;
                    }
                    else
                    {
                        postfix.push_back(tmp);
                        op_st.pop();
                    }
                }
            }
            else // 加减乘除运算符
            {
                if (op_st.empty())
                {
                    op_st.push(infix[i]);
                }
                else
                {
                    string tmp = op_st.top();
                    if (optors[infix[i]] > optors[tmp])
                    {
                        op_st.push(infix[i]);
                    }
                    else
                    {
                        while (!op_st.empty())
                        {
                            tmp = op_st.top();
                            if (tmp == "(")
                            {
                                break;
                            }
                            else if (optors[tmp] >= optors[infix[i]])
                            {
                                postfix.push_back(tmp);
                                op_st.pop();
                            }
                            else
                            {
                                break;
                            }
                        }
                        op_st.push(infix[i]);
                    }
                }
            }
        }
    }
    while (!op_st.empty())
    {
        postfix.push_back(op_st.top());
        op_st.pop();
    }
}

bool is_unknown(const string& str, const map<string, double>& unk_num)
{
    auto cit = unk_num.find(str);
    if (cit != unk_num.end())
    {
        return true;
    }
    else
    {
        return false;
    }
}

double cal_postfix(const vector<string>& postfix, const map<string, int>& optors, map<string, double>& unk_num)
{
    double ret = 0.0;
    stack<double> oe_st;
    for (auto i = 0; i < postfix.size(); ++i)
    {
        if (!is_operator(postfix[i], optors))
        {
            if (is_uncertain(postfix[i]))
            {
                oe_st.push(unk_num[postfix[i]]);
            }
            else
            {
                oe_st.push(static_cast<double>(atof(postfix[i].c_str())));
            }
        }
        else
        {
            double a(0.0), b(0.0), c(0.0);
            switch (postfix[i][0]) // 需要虚拟机技术啊
            {
            case '+':
                b = oe_st.top();
                oe_st.pop();
                a = oe_st.top();
                oe_st.pop();
                c = a + b;
                oe_st.push(c);
                break;

            case '-':
                b = oe_st.top();
                oe_st.pop();
                a = oe_st.top();
                oe_st.pop();
                c = a - b;
                oe_st.push(c);
                break;

            case '*':
                b = oe_st.top();
                oe_st.pop();
                a = oe_st.top();
                oe_st.pop();
                c = a * b;
                oe_st.push(c);
                break;

            case '/':
                b = oe_st.top();
                oe_st.pop();
                a = oe_st.top();
                oe_st.pop();
                c = a / b;
                oe_st.push(c);
                break;

            default:
                break;
            }
        }
    }

    ret = oe_st.top();
    oe_st.pop();
    return ret;
}


void display(const vector<string>& fix)
{
    for (auto i = 0; i != fix.size(); ++i)
    {
        cout << fix[i] << ' ';
    }
    cout << endl;
}

void init_operators(map<string, int>& optors)
{
    optors.clear();
    optors["+"] = 100;
    optors["-"] = 100;
    optors["*"] = 200;
    optors["/"] = 200;
    optors["("] = 500;
    optors[")"] = 000;
}

void input_unknown(map<string, double>& unk_num)
{
    cout << "Unknowns:" << endl;
    for (auto cit = unk_num.begin(); cit != unk_num.end(); ++cit)
    {
        cout << cit->first << ' ';
    }
    cout << endl;
    cout << "Input unknowns:" << endl;
    for (auto cit = unk_num.begin(); cit != unk_num.end(); ++cit)
    {
        double tmp;
        cout << cit->first << ':';
        cin >> tmp;
        cit->second = tmp;
    }
}

void display_known(const vector<string>& infix, map<string, double>& unk_num)
{
    for (auto i = 0; i < infix.size(); ++i)
    {
        if (is_uncertain(infix[i]))
        {
            cout << unk_num[infix[i]] << ' ';
        }
        else
        {
            cout << infix[i] << ' ';
        }
    }
    cout << endl;
}

void get_infix(string& algexp)
{
    cin.sync(); // 清空缓冲

    // fflush(stdin);

    algexp.clear();
    getline(cin, algexp);
}

int main()
{
    map<string, int> optors;
    init_operators(optors);

    while (true)
    {
        string algexp;
        get_infix(algexp);

        vector<string> infix;
        lexer(algexp, infix);

        display(infix);


        vector<string> postfix;
        map<string, double> unk_num;

        in_to_post(infix, postfix, unk_num, optors);

        display(postfix);

        if (!unk_num.empty())
        {
            input_unknown(unk_num);

            display_known(infix, unk_num);
        }

        double ret = cal_postfix(postfix, optors, unk_num);

        cout << ret << endl << endl;
    }

    return 0;
}

 

         在程序的处理过程中，我们只是默认对正确的代数表达式进行处理，针对三个阶段的异常并未作出相关的处理。

         有关异常情况的处理，我们可以用笨的方法进行硬分析，但是这种方法就是添加标识、考虑更可能多的情况。这种方法并不是最好的办法，只是说白了是苦力活。更好的方法是设计良好的数据结构，利用更有的算法，记住编译原理方面的技术进行分析。对于第一个方法我们不再做了，第二个方法有待我们进一步了解编译原理相关方面的内容。

         另外，在程序中关于根据加减乘除四种运算符的运算，我们是直接判断运算符，用的switch-case语句来进行的。更好的方法应该利用虚拟机技术，来完成运算符的运算操作。

         整体上，上面的程序就是分为三个部分：

         1.代数式的词法分析：lexer

         2.中缀转后缀：in_to_post

         3.后缀的计算：cal_post

         在中缀转后缀的过程中，我们记录了代数式中的未知量，并在转换后，对未知量进行赋值。在后缀的计算过程中，我们根据未知量复制后的值进行运算操作，最终得到代数式的运算结果。