算法学习记录-栈的应用--表达式运算

前面做了栈的基本操作

总感觉需要做一个实际的例子来检验一下。

这里我将用栈来做一个简单的四则运算。

目标比较简单：

做一个带小括号（“()”）的四则运算，如果要加入到中括号（“[]”）或者大括号（“{}”），依次类推。

求一个表达式：

用下面这个算是做例子，程序最后应该可以算出任何带小括号的运算。

3+（32-6）*9+5*3-（3*（65-15）/5）+12;

方法一：后缀法。

1.了解中缀和后缀表示法

中缀表示法：刚才的那个算是就是中缀表示法，我们通常看到的数学符号就是中缀表示法，即数字在计算符号的两边。

后缀表示法：所有的计算符号在数字之后。不包含括号，运算符放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向右进行。

原理：从左到右遍历表达式，如果是数字则输出，如果是符号：判断该符号与栈顶的符号优先级，

　　　　如果是右括号或者优先级低于栈顶符号，则栈中元素依次出栈并输出，并且将当前符号进栈。

对上面的式子进行处理：

后序表达式用处：

当转换成后序表达式后更方便计算表达式的值，如将后序表达式的元素依次进栈直到遇到运算符，这时候从栈中弹出两个元素，再结合运算符计算出这两个数运算的结果(如6-9=3)，将其结果压栈（此时栈元素为3 23 -3），然后继续将后序非符号元素压栈，直到遇到运算符。重复之前的操作。。。

InfixExp(中序表达式)转换PostfixExp(后序表达式)算法：

1）当输入的是操作数时候，直接输出到后序表达式PostfixExp序列中

2）当输入开括号时候，把它压栈

3）当输入的是闭括号时候，先判断栈是否为空，若为空，则发生错误并进行相关处理。若非空，把栈中元素依次弹出并输出到Postfix中，知道遇到第一个开括号，若没有遇到开括号，也发生错误，进行相关处理

4）当输入是运算符op（+、- 、×、/）时候

a)循环，当（栈非空and栈顶不是开括号and栈顶运算符的优先级不低于输入的运算符的优先级）时，反复操作：将栈顶元素弹出并添加到Postfix中

b)把输入的运算符op压栈

5）当中序表达式InfixExp的符号序列全部读入后，若栈内扔有元素，把他们依次弹出并放到后序表达式PostfixExp序列尾部。若弹出的元素遇到空括号，则说明不匹配，发生错误，并进行相关处理

编写了一个程序如下： 比较烂

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

using namespace std;

int get_proi(char ch)
{
    switch(ch)
    {
    case '+':
    case '-':return 1;

    case '*':
    case '/':return 2;

    case '(':
    case ')':return 3;
    }
}

void predo(string &str)
{
    string ot;
    int k=0;
    for (int i=0;i<str.size();i++)
    {
        if (isdigit(str[i]) || isspace(str[i]) || 
            str[i] == '+' || str[i] == '-' || str[i] == '*' || str[i] == '/' ||
            str[i] == '(' || str[i] == ')')
        {
            ot.push_back(str[i]);
        }
    }
    str = ot;
}

bool in_to_pre(string &str,vector<string> &vec)//中序-->后序
{
    vector<string> dest;
    stack<string> opstack;
    bool flag = false;
    int k=0;
    int i=0;
    //get every elem
    while(i<str.size())
    {
        i=k;
        string elem;
        if (isdigit(str[i]))
        {
            while(i<str.size() && isdigit(str[i]))
            {
                elem.push_back(str[i]);
                i++;
            }
            k = i;
            vec.push_back(elem);
        }
        else if (str[i] == '+' || str[i] == '-' || str[i] == '*' || str[i] == '/' || str[i] == '(' || str[i] == ')')
        {
            elem.push_back(str[i]);
            vec.push_back(elem);
            i++;
            k = i;
        }
    }
    // in to pre
    int deep = 0;
    for (vector<string>::iterator it = vec.begin();it!=vec.end();it++)
    {
        string tmp = *it;
        
        if (isdigit(tmp[0]))
        {//1如果是数字直接放入dest中
            dest.push_back(tmp);
        }
        else
        {//2如果是操作符则需要判断
            //2.1.如果是 “（”，压栈op
            if (tmp[0] == '(')
            {
                opstack.push(tmp);
                deep++;
            }
            //2.2.如果是 “）”，出栈直到“（”
            else if (tmp[0] == ')')
            {
                while(!opstack.empty() && opstack.top().at(0) != '(')
                {
                    dest.push_back(opstack.top());
                    opstack.pop();
                }
                if (opstack.empty())
                {
                    return -1;
                }
                else 
                {
                    deep--;
                    opstack.pop();
                }
            }
            //3.不是括号
            //3.1 循环，当（栈非空 and 栈顶不是开括号 and 栈顶运算符的优先级 不低于 输入的运算符的优先级）时，反复操作：将栈顶元素退出压入后序栈中
            else if (!opstack.empty() && opstack.top().at(0) != '(' && get_proi(opstack.top().at(0)) >= get_proi(tmp[0]))
            {
                while(!opstack.empty() && opstack.top().at(0) != '(' && get_proi(opstack.top().at(0)) >= get_proi(tmp[0]))
                {
                    dest.push_back(opstack.top());
                    opstack.pop();
                }
                opstack.push(tmp);
            }
            //3.2 压入 操作符 栈中
            else
            {
                opstack.push(tmp);
            }
        }
    }
    while(!opstack.empty())
    {
        dest.push_back(opstack.top());
        opstack.pop();
    }
    if (deep != 0)
    {
        return -1;
    }
    else
    {
        vec = dest;
        return 1;
    }
}

string cacl(string str1,string str2,string op,stack<string> &opt)
{
    char oo = op.at(0);
    double num1 = atof(str1.c_str());
    double num2 = atof(str2.c_str());
    double sum=0;
    switch(oo)
    {
    case '+':sum =  num1+num2;break;
    case '-':sum =  num1-num2;break;
    case '*':sum =  num1*num2;break;
    case '/':sum =  num1/num2;break;
    }
    
    char t[256];
    string s;

    sprintf(t, "%f", sum);
    s = t;
    return s;
}

void do_cacl(vector<string> &vec)
{
    stack<string> opt;
    for (vector<string>::iterator it = vec.begin();it!=vec.end();it++)
    {
        string tmp = *it;
        if (isdigit(tmp[0]))
        {
            opt.push(tmp);
        }
        else
        {
            string str2 = opt.top();
            opt.pop();
            string str1 = opt.top();
            opt.pop();
            
            opt.push(cacl(str1,str2,tmp,opt));
        }
    }
    cout<<opt.top();
}
int main()
{
    string in;
    getline(cin,in);
    predo(in);
    //not use negative
    vector<string> vecpre;
    in_to_pre(in,vecpre);
    
    do_cacl(vecpre);


    return 0;
}

2.运算的优先级：