栈：表达式求值（3.2实例引入）

(4)表达式求值

问题：表达式求值，只限于一位数。

算符优先级比较思路：op1：前一个操作符，也是栈顶操作符；op2：准备入栈的操作符

可以发现规律：

1）op1是 # 的时候，任何操作符都可以入栈（即任何操作符都比 # 优先级要高）。

2）op1是 + 或者 - 的时候，op2只有是 * 或者 / 或者 （ 可以入栈。

3）op1是 * 或者 / 的时候，op2只有是 （ 可以入栈。

4）op1是 （ 的时候，op2除了 ） 都可以入栈，遇到右括号则（）作为一对，要把（ 弹出。

算术优先级表

编辑环境：Code::Blocks 20.03

//主文件（顺序栈）
#include<iostream>
#include "Stack.h"
using namespace std;
//算术优先级比较函数
char comp(char op1,char op2)
{
    switch(op1){
        case '#':return '<';
        case '+':
        case '-':
            if(op2=='*'||op2=='/'||op2=='(')return '<';
            else return '>';
            break;
        case '*':
        case '/':
            if(op2=='(')return  '<';
            else return '>';
            break;
        case '(':
               if(op2==')')return '=';
               else return '<';
               break;
    }
}

void jisuan(Stack<double> &S1,Stack<char> &S2)
{
    double num1,num2;
    char op;
    S1.Pop(num2);S1.Pop(num1);S2.Pop(op);
    switch(op)
    {
        case '+':S1.Push(num1+num2);break;
        case '-':S1.Push(num1-num2);break;
        case '*':S1.Push(num1*num2);break;
        case '/':S1.Push(num1/num2);break;
    }
}
int main()
{
    Stack<double> S1;//数栈
    Stack<char> S2;//符号栈
    S1.InitStack();
    S2.InitStack();
    S2.Push('#');
    string str;
    double result;
    char e;
    cin>>str;
    for(int i=0;i<str.length()-1;)//入栈（等于号之前的数据）
    {
        if(str[i]>='0'&&str[i]<='9'){   S1.Push(str[i]-'0');i++;    }//要么数要么符号
        else
        {
            if(comp(S2.GetSElem(),str[i])=='<')
            {    S2.Push(str[i]);i++;   }
            else if(comp(S2.GetSElem(),str[i])=='=')
            {
                S2.Pop(e);i++;
            }
            else{
                    jisuan(S1,S2);
            }
        }
    }
    //剩下的全部出栈
    while(S2.GetSElem()!='#')
    {
        jisuan(S1,S2);
    }
    S1.Pop(result);
    cout<<result<<endl;
    return 0;
}

//Stack.h文件
#ifndef STACK_H
#define STACK_H
#include<iostream>
using namespace std;
typedef int Status;  //
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
template<class T>
class Stack
{
    private:
        T *base;
        T *top;
        int stacksize;
    public:
    void InitStack()
    {
        base = new T[MAXSIZE];  //
        if(!base)exit(OVERFLOW);
        top = base;
        stacksize=MAXSIZE;
    }
    Status Push(T e)
    {
        if(top-base==stacksize)return ERROR;
        *top++=e;
        return OK;
    }
    Status Pop(T &e)
    {
        if(top==base)return ERROR;
        e=*--top;
        return OK;
    }
    T GetSElem()//取栈顶元素
   {
        if(top!=base)
            return *(top-1);
    }
};

#endif //

运行结果：