蓝桥杯 表达式计算（栈）

表达式计算

问题描述

　　输入一个只包含加减乖除和括号的合法表达式，求表达式的值。其中除表示整除。

输入格式

　　输入一行，包含一个表达式。

输出格式

　　输出这个表达式的值。

样例输入

1-2+3*(4-5)

样例输出

-4

数据规模和约定

　　表达式长度不超过100，表达式运算合法且运算过程都在int内进行。

参考博客： http://blog.csdn.net/reidsc/article/details/54669433

这个题的思路就是先把中缀表达式转化为后缀表达式，然后用后缀表达式计算出式子的值

1.将中缀表达式转换为后缀表达式的方法：
(1) 初始化两个栈：运算符栈S1和储存中间结果的栈S2；
(2) 从左至右扫描中缀表达式；
(3) 遇到操作数时，将其压入S2，这里由于运算数可能大于10，所以如果数字后面一个符号是运算符，则将‘#’入S2栈充当分割线；
(4) 遇到运算符时有三种情况：
(4-1) 三种情况下直接入S1栈①S1为空②运算符为‘（’③运算符优先级比S1栈顶运算符的高；
(4-2)如果右括号“)”，则依次弹出S1栈顶的运算符，并压入S2，直到遇到左括号为止，此时将这一对括号丢弃；
(4-3) 若运算符优先级小于或等于S1栈顶运算符的优先级，则依次弹出S1栈顶元素，直到运算符的优先级大于S1栈顶运算符优先级；
(6) 重复步骤(2)至(5)，直到表达式的最右边；
(7) 将S1中剩余的运算符依次弹出并压入S2；
(8) 依次弹出S2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式。

运算符优先级： 左括号>（乘=除）>（加=减）>右括号  为了编程方便假定右括号优先级最小。

例：将 1 + ( ( 23 + 34 ) * 5 ) - 6转化为中缀表达式

扫描到的元素	S2(栈底->栈顶)	S1 (栈底->栈顶)	说明
1	1	空	数字，直接入栈，下一个元素是运算符#入栈
+	1	+	S1为空，运算符直接入栈
(	1	+ (	左括号，直接入栈
(	1	+ ( (	左括号，直接入栈
2	1 # 2	+ ( (	数字，直接入栈下一个元素不是运算符
3	1 # 2 3 #	+ ( (	数字，直接入栈，下一个元素是运算符#入栈
+	1 # 2 3 #	+ ( ( +	+优先级大于S1栈顶运算符，直接入栈.
3	1 # 2 3 # 3	+ ( ( +	数字，直接入栈，下一个元素不是运算符
4	1 # 2 3 # 3 4 #	+ ( ( +	数字，直接入栈，下一个元素是运算符#入栈
)	1 # 2 3 # 3 4 # +	+ (	右括号，弹出S1运算符直至遇到左括号，将弹出的元素压入S2中，丢弃一对括号
*	1 # 2 3 # 3 4 # +	+ ( *	*优先级大于S1栈顶运算符，直接入栈.
5	1 # 2 3 # 3 4 # + 5 #	+ ( *	数字，直接入栈，下一个元素是运算符#入栈
)	1 # 2 3 # 3 4 # + 5 # *	+	右括号，弹出S1运算符直至遇到左括号，将弹出的元素压入S2中，丢弃一对括号
-	1 # 2 3 # 3 4 # + 5 # * +	-	-与+优先级相同，因此弹出+，再压入-
6	1 # 2 3 # 3 4 # + 5 # * + 6 #	-	数字，直接入栈，下一个元素是运算符#入栈
到达最右端	1 # 2 3 # 3 4 # + 5 # * + 6 # -	空	S1中剩余的运算符弹出并压入S2

所以计算结果为：1 # 2 3 # 3 4 # + 5 # * + 6 # -

2.后缀表达式计算方法：

（1）定义一个int栈S3，定义一个整形数组num用来存储大于10的数字便于计算，从左至右扫描表达式。

（2）遇到数字时：

（2-1）若数字后面一个元素不是#（数字后面只可能是#或数字）则将数字字符转化为数字存在num[ ]数组中；

（2-2）若数字后面一个元素是#，将num数组中保存的数字算出来并压入S3栈中。

（3）遇到运算符时，弹出S3栈顶的两个数，用运算符对它们做相应的计算（次顶元素 op 栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果。

例如后缀表达式“1 # 2 3 # 3 4 # + 5 # * + 6 # -”：

扫描到的元素	S3(栈底->栈顶)	num[ ]（从左到右下标从0递增）	说明
1	1	1	数字，下一个元素为#故将num中算出来压入S3中
#	1	1	#,跳过，（下一次赋值从num[0]开始）
2	1	2	数字,下一个元素不为#故将元素转化为数字存入num中
3	1 23	2 3	数字,下一个元素为#故将num中算出来压入S3中
#	1 23	2 3	#,跳过
3	1 23	3 3	数字,下一个元素不为#故将元素转化为数字存入num中,注意从num[0]开始
4	1 23 34	3 4	数字,下一个元素为#故将num中算出来压入S3中
#	1 23 34	3 4	#，跳过
+	1 57	3 4	+，弹出S3栈顶两元素，进行加法计算后压入栈中
5	1 57 5	5 4	数字，下一个元素为#故将num中算出来压入S3中
#	1 57 5	5 4	#，跳过
*	1 285	5 4	*，弹出S3栈顶两元素，进行乘法计算后压入栈中
+	286	5 4	+，弹出S3栈顶两元素，进行加法计算后压入栈中
6	286 6	6 4	数字,下一个元素为#故将num中算出来压入S3中
#	286 6	6 4	#，跳过
-	280	6 4	-，弹出S3栈顶两元素，进行减法计算后压入栈中。

所以最后计算的结果为280

代码：

#include<stdio.h>
#include<math.h>
#include<stack>
#include<string.h>
#include<algorithm>
using namespace std;

stack<char>s1,s2;
stack<int>s3;
char ch[110]= {0};
int num[11];

int priority(char c)//比较运算符的优先级
{
    if(c=='(')
        return 4;
    if(c=='*'||c=='/')
        return 3;
    if(c=='+'||c=='-')
        return 2;
    if(c==')')
        return 1;
}

int Scal(int a,int b,char op)//两个数的运算
{
    if(op=='+')
        return a+b;
    if(op=='-')
        return a-b;
    if(op=='*')
        return a*b;
    if(op=='/'&&b)
        return a/b;
}

void Transform(int n)//将中缀表达式转化为后缀表达式
{
    int k=0;
    for(int i=0; i<n; i++)
    {
        if(ch[i]>='0'&&ch[i]<='9')//如果是数字
        {
            if(i+1<n&&(ch[i+1]<'0'||ch[i+1]>'9')||i==n-1)//当下一个是运算符，或者是最后一个字符时
            {
                s2.push(ch[i]);
                s2.push('#');
            }
            else
                s2.push(ch[i]);
        }
        else
        {
            if(s1.empty()||ch[i]=='('||priority(ch[i])>priority(s1.top()))//当是运算符时，有三种情况入栈
                s1.push(ch[i]);
            else if(ch[i]==')')//当为右括号时
            {
                while(s1.top()!='(')
                {
                    s2.push(s1.top());
                    s1.pop();
                }
                s1.pop();
            }
            else //当运算符优先级小于或等于s1栈顶运算符的优先级
            {
                while(!s1.empty()&&priority(ch[i])<=priority(s1.top())&&s1.top()!='(')//注意为空和是左括号时应当停止
                {
                    s2.push(s1.top());
                    s1.pop();
                }
                s1.push(ch[i]);
            }
        }
    }
  //对大佬的算法改进了一点  
  //大佬的  
//    while(!s1.empty())//表达式结束，将剩余的运算符弹出并压入s2
//    {
//        s2.push(s1.top());
//        s1.pop();
//    }
//    while(!s2.empty())//将s2中元素压入数组
//    {
//        ch[k++]=s2.top();
//        s2.pop();
//    }
//    reverse(ch,ch+k);//将ch[]反向
  //我的
    while(!s2.empty())//先将所有元素都移入s1中
    {
        s1.push(s2.top());
        s2.pop();
    }
    while(!s1.empty())
    {
        ch[k++]=s1.top();
        s1.pop();
    }
    ch[k]='\0';
}

int Cal(int n)//计算后缀表达式
{
    int x,y,tmp=0,k=0;
    for(int i=0; i<n; i++)
    {
        if(ch[i]=='#')
            continue;
        else if(ch[i]=='+'||ch[i]=='-'||ch[i]=='*'||ch[i]=='/')//是运算符，弹出栈顶两元素计算后再放回栈中
        {
            x=s3.top();
            s3.pop();
            y=s3.top();
            s3.pop();
            x=Scal(y,x,ch[i]);//注意x和y的顺序
            s3.push(x);
        }
        else//是数字字符
        {
            if(ch[i+1]=='#')
            {
                num[k++]=ch[i]-'0';
                for(int i=0; i<k; i++)
                    tmp+=(num[i]*(int)pow(10,k-i-1));
                s3.push(tmp);
                k=0,tmp=0;
            }
            else
                num[k++]=ch[i]-'0';
        }
    }
    return s3.top();
}

int main()
{
    gets(ch);
    Transform(strlen(ch));
    printf("%d\n",Cal(strlen(ch)));
    return 0;
}