蓝桥杯 算法训练：表达式计算 中缀表达式变后缀表达式

  算法训练 表达式计算  

时间限制：1.0s   内存限制：256.0MB

    

问题描述

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

输入格式

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

输出格式

　　输出这个表达式的值。

样例输入

1-2+3*(4-5)

样例输出

-4

数据规模和约定

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

下面这段话转自

http://www.nowamagic.net/librarys/veda/detail/2307

我们把平时所用的标准四则运算表达式，即“9+(3-1)*3+10/2"叫做中缀表达式。因为所有的运算符号都在两数字的中间，现在我们的问题就是中缀到后缀的转化。

中缀表达式“9+(3-1)*3+10/2”转化为后缀表达式“9 3 1-3*+ 10 2/+”

• 规则：从左到右遍历中缀表达式的每个数字和符号，若是数字就输出，即成为后缀表达式的一部分；若是符号，则判断其与栈顶符号的优先级，是右括号或优先级低于找顶符号（乘除优先加减）则栈顶元素依次出找并输出，并将当前符号进栈，一直到最终输出后缀表达式为止。

下面我们来具体看看这个过程。

1. 初始化一空栈，用来对符号进出栈使用。

2. 第一个字符是数字9，输出9，后面是符号“+”，进栈。

3. 第三个字符是“(”,依然是符号，因其只是左括号，还未配对，故进栈。

4. 第四个字符是数字3，输出，总表达式为9 3,接着是“-”进栈。

5. 接下来是数字1，输出，总表达式为9 3 1，后面是符号“)”，此时，我们需要去匹配此前的“(”，所以栈顶依次出栈，并输出，直到“(”出栈为止。此时左括号上方只有“-”，因此输出“-”，总的输出表达式为9 3 1 -

6. 接着是数字3，输出，总的表达式为9 3 1 - 3 。紧接着是符号“*”，因为此时的栈顶符号为“+”号，优先级低于“*”，因此不输出，进栈。

7. 之后是符号“+”，此时当前栈顶元素比这个“+”的优先级高，因此栈中元素出栈并输出（没有比“+”号更低的优先级，所以全部出栈），总输出表达式为 9 3 1 - 3 * +.然后将当前这个符号“+”进栈。也就是说，前6张图的栈底的“+”是指中缀表达式中开头的9后面那个“+”，而下图中的栈底（也是栈顶）的“+”是指“9+(3-1)*3+”中的最后一个“+”。

8. 紧接着数字10，输出，总表达式变为9 3 1-3 * + 10。

9. 最后一个数字2,输出，总的表达式为 9 3 1-3*+ 10 2

10. 因已经到最后，所以将栈中符号全部出栈并输出。最终输出的后缀表达式结果为 9 3 1-3*+ 10 2/+

• 从刚才的推导中你会发现，要想让计算机具有处理我们通常的标准（中缀）表达式的能力，最重要的就是两步：

1. 将中缀表达式转化为后缀表达式（栈用来进出运算的符号）。
2. 将后缀表达式进行运算得出结果（栈用来进出运算的数字）。

整个过程，都充分利用了找的后进先出特性来处理，理解好它其实也就理解好了栈这个数据结构。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stack>
using namespace std;
stack <double> stack_num; //数值栈
stack <char>  stack_ch;   //符号栈
char str[1000];  //表达式数组
char number[100];   //操作数数组


void calculate_1()
{
    char ch;
    double num1, num2;
    ch = stack_ch.top();
    while (ch != '(')
    {
        //num1,num2分别是栈顶和次顶元素，读取后并从栈中删除
        num1 = stack_num.top();
        stack_num.pop();
        num2 = stack_num.top();
        stack_num.pop();
        switch (ch)
        {
            case '+':
                num2+=num1;
                break;
            case '-':
                num2-=num1;
                break;
            case '*':
                num2*=num1;
                break;
            case '/':
                num2/=num1;
                break;
        }
        stack_num.push(num2); //计算结果num2入栈
        stack_ch.pop();  //删除已经用过的运算符栈顶元素
        ch = stack_ch.top();  //ch获取新的栈顶元素进行循环
    }
}
void calculate_2()
{
    char ch;
    double num1,num2;
    ch = stack_ch.top();
    while (ch == '*' || ch == '/')
    {
        num1 = stack_num.top();
        stack_num.pop();
        num2 = stack_num.top();
        stack_num.pop();
        switch(ch)
        {
            case '*':
                num2*=num1;
                break;
            case '/':
                num2/=num1;
                break;
        }
        stack_num.push(num2);
        stack_ch.pop();
        ch = stack_ch.top();
    }
}
int main()
{
    int i,k=0;
    char str1[2]="=";
    double n;
    gets(str);
    strcat(str,str1);
    stack_ch.push('(');
    for (i=0; str[i]; i++)
    {
        if (str[i]>='0' && str[i]<='9' || str[i]=='.')
          {
             number[k++] = str[i];
             continue;  //一个字符一个字符的获取一个操作数
          }
        number[k] = 0;
        if (number[0] != 0)
        {
            n = atof(number);
            number[0] = 0;
            stack_num.push(n);
        }
        k = 0;
        switch (str[i])
        {
            case '+':
                calculate_1();
                stack_ch.push('+');
                break;
            case '-':
                calculate_1();
                stack_ch.push('-');
                break;
            case '*':
                calculate_2();
                stack_ch.push('*');
                break;
            case '/':
                calculate_2();
                stack_ch.push('/');
                break;
            case '(':
                stack_ch.push('('); //左括号直接入栈
                break;
            case ')':
                calculate_1();  //将右括号与左括号之间的运算符都用上
                stack_ch.pop();//右括号不栈，并将栈顶的左括号删除
                break;
            case '=':
                calculate_1();
                stack_ch.pop();
                break;
         }


    }
    printf("%.0lf",stack_num.top());
    return 0;
}