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

#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;
}