PTA-求前缀表达式的值（C语言）（两种方法）（注释详细）

算术表达式有前缀表示法、中缀表示法和后缀表示法等形式。前缀表达式指二元运算符位于两个运算数之前，例如2+3*(7-4)+8/4的前缀表达式是：+ + 2 * 3 - 7 4 / 8 4。请设计程序计算前缀表达式的结果值。

输入格式:

输入在一行内给出不超过30个字符的前缀表达式，只包含+、-、*、/以及运算数，不同对象（运算数、运算符号）之间以空格分隔。

输出格式:

输出前缀表达式的运算结果，保留小数点后1位，或错误信息ERROR。

输入样例:

+ + 2 * 3 - 7 4 / 8 4

输出样例:

13.0

核心思想： 

学了栈的知识，得会运用，这题先以字符串的形式，输入一串字符，然后用字符串strlen函数求出字符串长度，从右往左遍历字符串，如果输入的是字符串，得把它类型转换为double类型，得到double类型数据后，记得入栈，字符串遍历遇到运算符，此时栈中一定已经有了至少两个数据，进行运算，运算结果再次入栈，如此反复，知道最后，栈中只剩下最后一个数，就是最终结果。

注意事项：用VS编译，gets函数，应该和scanf函数一样，加个后缀_s，gets_s。 

这里再给出几个例子，想深究的同学，可以尝试：

2.1 / 9 - - 8 4 4

- + 2.8 -1.2 * 6.32 100

 结果分别是，ERROR（除数为0了），-630.4

 

参考代码：

方法一：（循环）

（相对好理解一点）（我做了详细的解释，希望小白也能看懂，因为我自己也是小白。其中循环语句里，我假设输入的字符串数据有129 & 3.141两种，两次循环，两次对比，读者可以更直观地看懂每一步循环步骤的目的）

// 求前缀表达式的值（输入一个前缀表达式，算出其值）
// @ 法1：相对好理解点
#include <stdio.h>
#include <string.h>
#include <stdlib.h> // @ strlen、gets、puts函数
#define maxsize 35

typedef struct SNode* stack;    // @ 栈指针
struct SNode    // @ 栈结点
{
    double data[maxsize];  // @ 创建栈，就是为了存放输入字符串中的double类型数据
    int top;    // @ 栈顶 就是int类型，不是指针类型
};

stack creat()
{
    stack s = (stack)malloc(sizeof(struct SNode));
    s->top = -1;
    return s;
}

void push(stack s, double x)    // @ 入栈
{
    s->data[++s->top] = x;
}

double pop(stack s)     // @ 出栈
{
    return s->data[s->top--];
}

void calculate(stack s, double op1, double op2, char str)
{
    switch (str) {
    case '+':
        push(s, op1 + op2); // @ 函数不含返回值，本身就有入栈操作
        break;
    case '-':
        push(s, op1 - op2);
        break;
    case '*':
        push(s, op1 * op2);
        break;
    case '/':
        push(s, op1 / op2);
        break;
    default:
        break;
    }
}

char a[maxsize];
int main()
{
    gets(a);  // @ 输入
    int l = strlen(a);  // @ 字符长
    stack s = creat();
    int i = l - 1;
    for (int i = l - 1; i >= 0; i--)    // @ 从右往左，依次入栈
    {
        if (a[i] >= '0' && a[i] <= '9') // @ 如果是数字      比如 129 & 3.141
        {
            double x = a[i] - '0';//char->double @ 类型转换     x此时：9 & 1
            double m = 10; // 预备小数的情况
            i = i - 1;  // @ 因为下面需要获取a[i]前面的字符
            for (; i >= 0; i--) // @ i--，所以下面的 a[i]是数字前面的字符
            {
                if (a[i] >= '0' && a[i] <= '9') // @ 前面还是数字，要么小数，要么大于9
                {
                    x += m * (a[i] - '0');  // @ 此操作，x = 一个两位数了     x此时：29 & 41
                    m *= 10;  // @ 如果还来循环的话，x就要 * 100了，所以 m*=10  再循环一次，x此时：129 & 141
                }
                else if (a[i] == '.') //小数点，说明这个数是个小数
                {
                    x /= m; // @ x此时 不循环至此 & 0.141（double型）
                    m = 1;  // @ 重命名m = 1
                }
                else if (a[i] == '-') //负数符号，说明这个数是负数
                {
                    x = -x; 
                }
                else break; // @ 四种情况
            }
            push(s, x); // @ 循环结束，别忘了入栈。x此时：129 & 3.141   入栈！
        }
        else if (a[i] == '+' || a[i] == '-' || a[i] == '*' || a[i] == '/')
        { // @ 不是数字，而是运算符
            double op1 = pop(s);
            double op2 = pop(s);
            if (a[i] == '/' && op2 == 0)  // @ 别忘了，如果遇到 0作被除数的情况，值7分
            {
                printf("ERROR");
                return 0;  // @ 单独占两分，“非正常退出”，确实要提前return 0；退出，不然后面的循环就全崩掉了
            }
            calculate(s, op1, op2, a[i]);
        } // @ 再循环
    }
    if (s->top == 0) // @ 确保：栈只有最后一个元素了，也就是最终答案
        printf("%.1f\n", pop(s));
    else
        printf("ERROR");
    return 0;
}

方法二：（递归）

（代码简洁，难理解）

（递归，我也没搞懂，会第一种方法我知足了）

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
double exp();

int main()
{
    printf("%.1f", exp());
    return 0;
}

double exp()
{
    char a[10];
    scanf("%s", a, 10);

    if (!a[1]) // @ a[1] == 0
    {
        switch (a[0])
        {
        case '+':
            return exp() + exp();
        case '-':
            return exp() - exp();
        case '*':
            return exp() * exp();
        case '/':
        {
            double fenzi = exp(); // @ 分子
            double fenmu = exp(); // @ 分母
            if (fenmu != 0) return fenzi / fenmu;
            else
            {
                printf("ERROR");
                exit(0);
            }
        }
        default:
            return atof(a);
        }
    }
    else
    {
        if (a[0] == '-' || a[0] == '+')
        {
            char flag = a[0];
            int i = 0;
            while (a[i])
            {
                a[i] = a[i + 1];
                i++;
            }
            if (flag == '-')
                return 0 - atof(a);
            else return atof(a);
        }
        else return atof(a);
    }
}

温故而知新

11.1复习

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define Maxsize 30


typedef struct
{
	double arr[Maxsize];
	int top;
}SNode;
typedef SNode* Stack;

Stack StackCreat()
{
	Stack s = (Stack)malloc(sizeof(SNode));
	s->top = -1;
	return s;
}


void push(Stack s, double x)
{
	s->arr[++s->top] = x;
}


double pop(Stack s)
{
	return s->arr[s->top--];
}

int main()
{
	Stack s = StackCreat();
	char str[Maxsize];
	gets(str);
	int l = strlen(str);  // @ 没写出来
	int i = l--;
	for (; i >= 0; i--)
	{
		if (str[i] >= '0' && str[i] <= '9')
		{
			double x = str[i] - '0';  // @ 应该在循环外！
			double m = 10;
			for (i--; i >= 0; i--)
			{
				if (str[i] <= '9' && str[i] >= '0')
				{
					x = x + (str[i] - '0') * m;
					m = m * 10;
				}
				else if (str[i] == '.')
				{
					x = x / m;
					m = 1;
				}
				else if (str[i] == '-')
					x = -x;
				else
					break;
			}
			push(s, x);
		}
		else if (str[i] == '+')
			push(s, pop(s) + pop(s));
		else if (str[i] == '-')
			push(s, pop(s) - pop(s));
		else if (str[i] == '*')
			push(s, pop(s) * pop(s));
		else if (str[i] == '/')
		{
			double num1 = pop(s), num2 = pop(s);
			if (num2 == 0)
			{
				printf("ERROR"); // @ 必须要写
				return 0;  // @ 单独占两分，“非正常退出”，
							//确实要提前return 0；退出，不然后面的循环就全崩掉了
			}
			else
				push(s, num1 / num2);
		}
	}
	if (s->top == 0)
		printf("%.1f", pop(s));
	else
		printf("ERROR");
}

制作不易，能点个赞支持一下吗，您的鼓励，是我前行的最大动力！