【数据结构与算法实验】栈实现简单综合四则运算

实验目的：

在代码实践中熟悉栈这一重要线性结构，提高项目规划能力，提高写代码熟练度。

预期效果：

输入 8/4/1+1024/16*18-22*7

输出 1000

实验思路：

前提：运算数最多为4位数且都为正整数，结果取编程整数计算结果（即不取小数），不考虑括号

创建两个栈，一个用于存放读入的数字，另一个用于存放读入的运算符

当读入是数字时，直接入数字栈。

当读入是运算符时，若运算符栈空，则直接入栈，否则比较该运算符与运算符栈顶运算符，若优先级较大，则入栈；若优先级较小或相等，则pop出运算符栈顶运算符，同时pop出数字栈的前两个数字进行运算（此处注意减法与除法的顺序问题），将结果入数字栈，最后再将读入的运算符入栈。

表达式读取结束后，再对栈中所有数据进行计算处理得到结果。

实验代码：

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
​
#define ElementType int
#define MAXSIZE 100
​
/* 栈代码实现 */
struct StackNode {
    ElementType data[MAXSIZE];
    int Top;
};
typedef struct StackNode *Stack;
​
Stack createStack() {
    Stack S = (Stack)malloc(sizeof(struct StackNode));
    S->Top = -1;
​
    return S;
}
bool isEmpty(Stack S) {
    if (S->Top < 0) {
        return true;
    }
    else {
        return false;
    }
​
}
bool isFull(Stack S) {
    if (S->Top == MAXSIZE-1) {
        return true;
    }
    else {
        return false;
    }
}
void push(Stack S, ElementType X) {
    if(isFull(S)) puts("Error! Stack is full.");
    else S->data[++(S->Top)] = X;
}
ElementType pop(Stack S) {
    if(isEmpty(S)) puts("Error! Stack is empty.");
    else return S->data[(S->Top)--];
}
ElementType get(Stack S) {
    if(isEmpty(S)) puts("Error! Stack is empty.");
    else return S->data[(S->Top)];
}
/* 栈代码实现 完*/
​
/* 主程序 */
​
// 运算函数实现
int calculation (int num1,int num2,char operation) {
    if (operation == '+') {
        return (num1+num2);
    }
    else if (operation == '-') {
        return (num1-num2);
    }
    else if (operation == '*') {
        return (num1*num2);
    }
    else if (operation == '/') {
        return (num1/num2);
    }
}
​
// 得到运算符优先级函数实现
int getPriority(char c) {
    switch (c) {
        case '+': return 1;
        case '-': return 1;
        case '*': return 2;
        case '/': return 2;
    }
}
​
int main() {
    // 创建两个栈，分别用于存储数字与运算符
    Stack numStack = createStack();
    Stack OperationStack = createStack();
​
    // 初始化临时变量
    int numLocation = 0;
    char numString[4];
    char currentChar;
    bool error = false;
​
    // 循环读取输入内容
    while(true) {
        currentChar = getchar();
        // 当读取到数字
        if (currentChar>='0' && currentChar<='9') {
            if (numLocation > 3) {
                puts("Error! Number out of given range.");
                error = true;
                break;
            } else {
                numString[numLocation++] = currentChar;
            }
        }
        // 当读取到运算符
        else if (currentChar == '+' || currentChar == '-' || currentChar == '*' || currentChar == '/') {
            // 处理该运算符前暂存的数字
            if (numLocation == 0) {
                puts("Error! Wrong expression.");
                error = true;
                break;
            } else {
                push(numStack,atoi(numString));
                numLocation = 0;
                for (int i=0; i<4; i++) {
                    numString[i] = '\0';
                }
                // 处理运算符
                if (isEmpty(OperationStack)) {
                    push(OperationStack,currentChar);
                } else {
                    if (getPriority(currentChar) > getPriority(get(OperationStack))) {
                        push(OperationStack,currentChar);
                    } else {
                        int num2 = pop(numStack);
                        int num1 = pop(numStack);
                        int Op = pop(OperationStack);
                        if (Op=='/'&&num2==0) {
                            puts("Error! Divisor is 0.");
                            error = true;
                        }
                        else {
                            push(numStack,calculation(num1,num2,Op));
                            push(OperationStack,currentChar);
                        }
                    }
                }
            }
​
        }
        // 当读取到的既不是数字也不是运算符，则停止
        else {
            // 将最后暂存的数字压入数字堆栈
            push(numStack,atoi(numString));
            numLocation = 0;
            for (int i=0; i<4; i++) {
                numString[i] = '\0';
            }
            break;
        }
    }
​
    // 退出循环后，检测是否因错误退出
    if (error) {
        puts("The program was shutdown due to an error.");
        getchar();
        getchar();
        return 1;
    }
    // 若不是因错误退出，则完成最终计算并打印结果
    else {
        while (!isEmpty(OperationStack)) {
            int num2 = pop(numStack);
            int num1 = pop(numStack);
            int Op = pop(OperationStack);
            if (Op=='/'&&num2==0) {
                puts("Error! Divisor is 0.");
                error = true;
            }
            else {
                push(numStack,calculation(num1,num2,Op));
            }
        }
        printf("%d\n",numStack->data[numStack->Top]);
​
    }
​
    getchar();
    return 0;
}

测试结果：