PTA 简单计算器 (实验)

本题要求你为初学数据结构的小伙伴设计一款简单的利用堆栈执行的计算器。如上图所示，计算器由两个堆栈组成，一个堆栈 S1 存放数字，另一个堆栈 S2 存放运算符。计算器的最下方有一个等号键，每次按下这个键，计算器就执行以下操作：

1. 从 S1 中弹出两个数字，顺序为 n1 和 n2；
2. 从 S2 中弹出一个运算符 op；
3. 执行计算 n2 op n1；
4. 将得到的结果压回 S1。

直到两个堆栈都为空时，计算结束，最后的结果将显示在屏幕上。

输入格式：

输入首先在第一行给出正整数 N（1<N≤103），为 S1 中数字的个数。

第二行给出 N 个绝对值不超过 100 的整数；第三行给出 N−1 个运算符 —— 这里仅考虑 +、-、*、/ 这四种运算。一行中的数字和符号都以空格分隔。

输出格式：

将输入的数字和运算符按给定顺序分别压入堆栈 S1 和 S2，将执行计算的最后结果输出。注意所有的计算都只取结果的整数部分。题目保证计算的中间和最后结果的绝对值都不超过 109。

如果执行除法时出现分母为零的非法操作，则在一行中输出：ERROR: X/0，其中 X 是当时的分子。然后结束程序。

输入样例 1：

5
40 5 8 3 2
/ * - +

输出样例 1：

2

输入样例 2：

5
2 5 8 4 4
* / - +

输出样例 2：

ERROR: 5/0

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

解题

流程图

代码

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef enum {
    false, true
} bool;
typedef int Position;

typedef struct Node *PtrToIntNode;

struct Node {
    ElementType *data;  /* 存储元素的数组 */
    Position top;       /* 栈顶指针       */
    int MaxSize;        /* 堆栈最大容量   */
};

typedef PtrToIntNode Stack;

Stack CreateStack(int MaxSize) {
    Stack S = (Stack) malloc(sizeof(struct Node));
    S->data = (ElementType *) malloc(MaxSize * sizeof(ElementType));
    S->top = -1;
    S->MaxSize = MaxSize;
    return S;
}


ElementType Pop(Stack S);

bool Push(Stack S, ElementType X);

int main() {
    int n, i, temp;
    scanf("%d", &n);
    if (n < 1 || n > 1000) {
        return 0;
    }
    Stack stack1 = CreateStack(n);
    Stack stack2 = CreateStack(n - 1);

    for (i = 0; i < n; i++) {
        scanf("%d", &temp);
        Push(stack1, temp);
    }
    char c;
    getchar();
    for (i = 0; i < n - 1; i++) {
        scanf("%c", &c);
        getchar();
        Push(stack2, c);
    }
    int num1, num2, result;
    char op;
    int flag = 0;
    for (i = 0; i < n - 1; i++) {
        //弹出数字1
        num1 = Pop(stack1);
        //弹出数字2
        num2 = Pop(stack1);
        //再弹出一个符号
        op = Pop(stack2);
        //排除num2/0的情况
        if (num1 == 0 && op == '/') {
            flag = 1;
            break;
        }
        switch (op) {
            case '+':
                result = num2 + num1;
                break;
            case '-':
                result = num2 - num1;
                break;
            case '*':
                result = num2 * num1;
                break;
            case '/':
                result = num2 / num1;
                break;
            default:
                return -1;
        }
        Push(stack1, result);
    }
    if (flag == 1) {
        printf("ERROR: %d/%d\n", num2, num1);
    } else {
        printf("%d\n", stack1->data[stack1->top]);
    }
    return 0;
}


bool Push(Stack S, ElementType X) {
    if (S->top == S->MaxSize - 1) {
        //栈满
        return false;
    }
    S->data[++(S->top)] = X;
    return true;
}


ElementType Pop(Stack S) {
    if (S->top == -1) {
        //栈空
        return 0;
    }

    return S->data[(S->top)--];
}