括号匹配检测 逆波兰表达式

#include <iostream>
using namespace std;
#include <stack>

bool Check_Bracket(char* p)
{
    char* tmp = p;
    stack<char> s;

    while(*tmp != 0)
    {
        if(*tmp == '(' || *tmp == '[' || *tmp == '{')
        {
            s.push(*tmp);
            tmp++;
        }
        else if(*tmp == ')' || *tmp == ']' || *tmp == '}')
        {
            if(!s.empty())
            {
                if(((s.top() == '(') && (*tmp == ')')) ||
                   ((s.top() == '[') && (*tmp == ']')) ||
                   ((s.top() == '{') && (*tmp == '}')))
                {
                    s.pop();
                    tmp++;
                }
                else
                {
                    cout<<"左右括号次序匹配不正确"<<endl;
                    return false;
                }
            }
            else
            {
                cout<<"右括号多于左括号"<<endl;
                return false;
            }
        }
        else
            tmp++;
    }
    if(s.empty())
    {
        cout<<"左右括号匹配正确"<<endl;
        return true;
    }
    cout<<"左括号多于右括号"<<endl;
    return false;
}

int main()
{
    char* a = "(())abc{[(])}" ; // 左右括号次序匹配不正确
    char* b = "(()))abc{[]}" ; // 右括号多于左括号
    char* c = "(()()abc{[]}" ; // 左括号多于右括号
    char* d = "(())abc{[]()}" ; // 左右括号匹配正确

    cout<<Check_Bracket(a)<<endl;
    cout<<Check_Bracket(b)<<endl;
    cout<<Check_Bracket(c)<<endl;
    cout<<Check_Bracket(d)<<endl;

    return 0;
}

逆波兰表达式

逆波兰表达式又叫做后缀表达式。在通常的表达式中，二元运算符总是置于与之相关的两个运算对象之间，所以，这种表示法也称为中缀表示。波兰逻辑学家J.Lukasiewicz于1929年提出了另一种表示表达式的方法。按此方法，每一运算符都置于其运算对象之后，故称为后缀表示。

用途

逆波兰表达式是一种十分有用的表达式，它将复杂表达式转换为可以依靠简单的操作得到计算结果的表达式。例如12*(3+4)-6+8/2转换为12 3 4 + * 6 - 8 2 /

优势

它的优势在于只用两种简单操作，入栈和出栈就可以搞定任何普通表达式的运算。其运算方式如下：

如果当前字符为变量或者为数字，则压栈，如果是运算符，则将栈顶两个元素弹出作相应运算，结果再入栈，最后当表达式扫描完后，栈里的就是结果。

#include <iostream>
#include <stack>
using namespace std;

enum OPERATOR{ADD, SUB, MUL, DIV, DATA};

struct Cell
{
    //vc08不支持的语法，貌似13之后可以
    //Cell(int data, OPERATOR op = DATA)
    //  :_operator(op)
    //  ,_data(data)
    //{}

    OPERATOR _operator;
    int _data;
};

int Reverse_Polish_Notation(Cell Data[], int size)
{
    stack<int> s;

    for(int i = 0; i < size; i++)
    {
        if(Data[i]._operator == DATA)
            s.push(Data[i]._data);
        else
        {
            int right = s.top();
            s.pop();
            int left = s.top();
            s.pop();
            switch(Data[i]._operator)
            {
            case ADD:
                s.push(left+right);
                break;
            case SUB:
                s.push(left-right);
                break;
            case MUL:
                s.push(left*right);
                break;
            case DIV:
                if(right == 0)
                {
                    cout<<"除数为0"<<endl;
                    return 0;
                }

                s.push(left/right);
                break;
            default:
                cout<<"错误的操作"<<endl;
            }
        }
    }
    return s.top();
}

int main()
{
    Cell arr[] = 
    {{DATA, 12}, {DATA, 3}, {DATA, 4}, {ADD, 0}, {MUL, 0},
     {DATA, 6}, {SUB, 0}, {DATA, 8}, {DATA, 2},{DIV, 0}, {ADD, 0}};
    cout<<Reverse_Polish_Notation(arr, sizeof(arr)/sizeof(arr[0]))<<endl;

    return 0;
}