四则运算三c++ -(3)

num=rand()%maxn; fout << num; cout<

while(brack_cnt--) //补全右括号 {

fout << \ cout << \ }

cout<<\ fout<< endl; cout<

bool isNum(char x) //判断是否是数字 {

return (x >= '0' && x <= '9'); }

bool isOp(char x) //判断是否是操作符 {

return (x == '+' || x == '-' || x == '*' || x == '/' || x == '(' || x == ')'); }

int priority(char x) //返回一个操作符的优先级 {

if (x == '-' || x == '+') return 1;

else if (x == '*' || x == '/') return 2; else if (x == '(') return 0; else

return -1; }

bool nifix_to_post() {

memset(post, 0, sizeof(post));

stack s; //操作符栈，用来压操作符 /*

************************************************************************************************

# 由于操作数是多位的，所以我们逐位做一个累加暂存的工作，当遇到操作符时，代表此操作符前的数暂存完毕，

# 需要将其入栈，但也不是所有操作符前都有操作数，如'*('等，所以我们需要一个标志位来表示某个操作符前 # 是否进行过暂存操作数的处理。

*///************************************************************************************************** bool havenum = false;

int tmp = 0, pos = 0; //tmp为暂存多位数的变量，pos为后缀数组存储位置

for (int i = 0; nifix[i] != '\\0'; i++) //循环遍历中缀数组 {

if (isNum(nifix[i])) //若当前字符是数字，则进行暂存操作。并标识已有操作数 {

havenum = true;

tmp = tmp*10 + (nifix[i]-'0'); }

else if (isOp(nifix[i])) //若当前字符是操作符则进行如下操作 {

//中缀表达式合法性判断，判断是否有连续两个字符相连，若有则代表出错

if (isOp(nifix[i-1]) && nifix[i-1] != ')' && nifix[i] != '(') return true;

//如果操作符前有操作数，则将得到的操作数输出至后缀表达式

if (havenum) {

havenum = false; post[pos++] = tmp + '0'; tmp = 0; }

//如果操作符为右括号，则按规则进行出栈如后缀表达式等操作 if (nifix[i] == ')') {

if (s.empty()) //中缀表达式合法性判断，判断括号匹配 return true; while(s.top() != '(') {

post[pos++] = s.top(); s.pop();

if (s.empty()) //中缀表达式合法性判断，判断括号匹配 return true; } s.pop(); }

else if (nifix[i] == '(') //如果是左括号则直接入栈 s.push(nifix[i]);

else //如果是+-*/则按规则操作 {

while (!s.empty() && priority(nifix[i]) <= priority(s.top())) {

post[pos++] = s.top(); s.pop(); }

s.push(nifix[i]); } }

else //中缀表达式合法性判断，判断是否含非法符号 return true;

}

//若有操作数，则将其输出至后缀表达式 if (havenum) {

havenum = false; post[pos++] = tmp + '0'; tmp = 0; }

//将栈中操作符一次输出到后缀表达式中 while(!s.empty()) {

if (s.top() == '(') //中缀表达式合法性判断，判断括号匹配 return true; post[pos++] = s.top(); s.pop(); }

return false; }

ll gcd(ll m, ll n) { ll tmp; tmp = m % n; while(tmp) { m = n; n = tmp; tmp = m % n; } return n; }

bool cal_result() {

stack s; //用来存放操作数的栈 for (int i = 0; i < (strlen(post)); i++) //循环遍历后缀表达式

{

if (!isOp(post[i])) //如果是数字则直接入栈 {

num tmp(post[i]-'0', 1); s.push(tmp); } else {

//取出两个操作数，如果操作数数量不够，则出错，返回 if (s.empty()) return true;

num b = s.top(); s.pop(); if (s.empty()) return true;

num a = s.top(); s.pop(); num c;

if (post[i] == '+') //操作符是'+'，进行上述规则运算 {

c.numerator = a.numerator * b.denominator + b.numerator * a.denominator; c.denominator = a.denominator * b.denominator; }

else if (post[i] == '-') //操作符是'-'，进行上述规则运算 {

c.numerator = a.numerator * b.denominator - b.numerator * a.denominator; c.denominator = a.denominator * b.denominator; }

else if (post[i] == '*') //操作符是'*'，进行上述规则运算 {

c.numerator = a.numerator * b.numerator; c.denominator = a.denominator * b.denominator; }

else if (post[i] == '/') //操作符是'/'，进行上述规则运算 {