栈的应用：逆波兰表达式求值

Hello，本篇博客Val主要来给大家分享一下栈的一个用途：逆波兰表达式求值。

逆波兰表达式也叫后缀表达式，先操作数，后操作符。
栈 后进先出 ，顺序遍历波兰表达式，遇到操作数的时候入栈 ， 遇到操作符，先让操作数出栈运算操作数，然后再把运算结果入栈，所有的算式都可以用逆波兰表达式写出来。

把算式12*(3+4)-6+8/2+2用逆波兰表达式写出来，就是 12 3 4 + * 6 - 8 2 / +2 +
逆波兰表达式也叫后缀表达式，有的题目会给你一个算术表达式，求出它的后缀表达式。

如图：逆波兰表达式的操作数入栈运算方式、遇到操作符进行运算后将结果压入栈

#pragma once

#include 
#include 
#include 
using namespace std;

enum Type
{
    OP_NUM,
    OP_SYMBOL,
    ADD,
    SUB,
    MUL,
    DIV,
};
struct Cell
{
    Type _type;
    int _value;
};

int CountRPN(Cell *rpn, size_t n)//
{
    stack<int> s;
    for (size_t i = 0; i < n; i++)
    {
        if (rpn[i]._type == OP_NUM)//是操作数  入栈
        {
            s.push(rpn[i]._value);
        }
        else//遇到了操作符
        {
            int right = s.top(); //右操作数在左操作数之后入栈
            s.pop();
            int left = s.top();//左操作数
            s.pop();
            switch (rpn[i]._value)//看它是哪个操作符，就执行哪个，把结果再放入栈中
            {
            case ADD:
                s.push(left + right);
                break;
            case SUB:
                s.push(left - right);
                break;
            case MUL:
                s.push(left * right);
                break;
            case DIV:
                s.push(left / right);
                break;
            }
        }
    }
    assert(s.size() == 1);//最后结束时，栈里应该只有一个数据，为最终结果
    return s.top();//返回栈顶数据（最终结果）
}
//12*(3+4)-6+8/2+2
int main()
{
    Cell RPN[] =
    {
        { OP_NUM, 12 },
        { OP_NUM, 3 },
        { OP_NUM, 4 },
        { OP_SYMBOL, ADD },
        { OP_SYMBOL, MUL },
        { OP_NUM, 6 },
        { OP_SYMBOL, SUB },
        { OP_NUM, 8 },
        { OP_NUM, 2 },
        { OP_SYMBOL, DIV },
        { OP_SYMBOL, ADD },
        { OP_NUM, 2 },
        { OP_SYMBOL, ADD },

    };
    cout << sizeof(RPN) << " " << sizeof(Cell) << endl;
    cout << "结果：" << CountRPN(RPN, sizeof(RPN) / sizeof(Cell)) << endl;
    system("pause");
    return 0;
}

　　关于栈的运用：逆波兰表达式就分享到这里啦！
　　逆波兰表达式同过栈对其操作（遇到操作数入栈，遇到操作符，运算栈里的数据，再将其放回栈中），这样运算结束后，如果运算正确，栈中只有一个数据（也是栈顶数据），就是算术表达式的值。