用c语言实现：用栈完成从键盘输入一个算数表达式，完成表达式求值，其中表达式中数字可以为一位数，表达式中的符号包括加、减、乘、除、小括号，其中优先计算括号里的式子。写出实验代码，实验思路及实验结果。

实验思路：

1. 创建一个字符类型的栈，用于存储算数表达式中的数字和符号。

2. 从键盘输入算数表达式，并将每个字符依次入栈。

3. 如果遇到左括号，将左括号入栈；

4. 如果遇到右括号，弹出栈中元素并进行计算，直到遇到左括号为止；

5. 如果遇到加、减、乘、除符号，判断栈顶元素是否为优先级较高的符号（乘、除、括号），如果是，则弹出栈顶元素进行计算；

6. 将最终结果输出。

实验代码：

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

#define MAX_SIZE 100

// 定义栈结构
typedef struct {
    char data[MAX_SIZE];
    int top;
} Stack;

// 初始化栈
void initStack(Stack *s)
{
    s->top = -1;
}

// 判断栈是否为空
int isEmpty(Stack *s)
{
    return s->top == -1;
}

// 判断栈是否已满
int isFull(Stack *s)
{
    return s->top == MAX_SIZE - 1;
}

// 入栈
void push(Stack *s, char c)
{
    if (isFull(s)) {
        printf("栈已满，无法入栈\n");
        exit(1);
    }
    s->data[++s->top] = c;
}

// 出栈
char pop(Stack *s)
{
    if (isEmpty(s)) {
        printf("栈为空，无法出栈\n");
        exit(1);
    }
    return s->data[s->top--];
}

// 获取栈顶元素
char peek(Stack *s)
{
    if (isEmpty(s)) {
        printf("栈为空，无法获取栈顶元素\n");
        exit(1);
    }
    return s->data[s->top];
}

// 判断是否为数字
int isDigit(char c)
{
    return c >= '0' && c <= '9';
}

// 判断是否为运算符
int isOperator(char c)
{
    return c == '+' || c == '-' || c == '*' || c == '/';
}

// 判断运算符优先级
int getPriority(char c)
{
    if (c == '(' || c == ')') {
        return 0;
    } else if (c == '+' || c == '-') {
        return 1;
    } else if (c == '*' || c == '/') {
        return 2;
    } else {
        return -1;
    }
}

// 计算两个数的值
int calculate(int a, int b, char op)
{
    int result = 0;
    switch (op) {
        case '+':
            result = a + b;
            break;
        case '-':
            result = a - b;
            break;
        case '*':
            result = a * b;
            break;
        case '/':
            result = a / b;
            break;
    }
    return result;
}

// 计算表达式的值
int evaluate(char *expression)
{
    Stack s;
    initStack(&s);
    int i = 0;
    while (expression[i] != '\0') {
        // 如果是数字，则直接入栈
        if (isDigit(expression[i])) {
            push(&s, expression[i]);
        } else if (isOperator(expression[i])) {
            // 如果是运算符，则判断栈顶元素的优先级
            if (isEmpty(&s) || getPriority(expression[i]) > getPriority(peek(&s))) {
                push(&s, expression[i]);
            } else {
                // 如果栈顶元素的优先级大于等于当前运算符，则弹出栈顶元素进行计算
                int b = pop(&s) - '0';
                int a = pop(&s) - '0';
                int result = calculate(a, b, expression[i]);
                push(&s, result + '0');
            }
        } else if (expression[i] == '(') {
            // 如果是左括号，则直接入栈
            push(&s, expression[i]);
        } else if (expression[i] == ')') {
            // 如果是右括号，则弹出栈中元素进行计算，直到遇到左括号为止
            while (peek(&s) != '(') {
                int b = pop(&s) - '0';
                char op = pop(&s);
                int a = pop(&s) - '0';
                int result = calculate(a, b, op);
                push(&s, result + '0');
            }
            pop(&s); // 弹出左括号
        }
        i++;
    }
    // 计算最终结果
    while (!isEmpty(&s)) {
        int b = pop(&s) - '0';
        char op = pop(&s);
        int a = pop(&s) - '0';
        int result = calculate(a, b, op);
        push(&s, result + '0');
    }
    return pop(&s) - '0';
}

int main()
{
    char expression[MAX_SIZE];
    printf("请输入算数表达式：");
    scanf("%s", expression);
    int result = evaluate(expression);
    printf("计算结果：%d\n", result);
    return 0;
}

实验结果：