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

思路：

1. 首先定义一个栈结构体，包括栈顶指针和栈数组。

2. 定义一个函数，用来判断输入的字符是不是数字。

3. 定义一个函数，用来将中缀表达式转换成后缀表达式。

4. 定义一个函数，用来计算后缀表达式的值。

1. 遍历后缀表达式，如果是数字则入栈。

2. 如果是操作符，则弹出两个数进行运算，将结果入栈。

3. 最后栈中只剩下一个数，即为表达式的值。

实验代码如下：

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

#define MAX_STACK_SIZE 100

typedef struct {
    int top;
    int data[MAX_STACK_SIZE];
} Stack;

int is_digit(char c) {
    return isdigit(c);
}

void push(Stack *s, int value) {
    s->data[++s->top] = value;
}

int pop(Stack *s) {
    return s->data[s->top--];
}

int peek(Stack *s) {
    return s->data[s->top];
}

int is_empty(Stack *s) {
    return s->top == -1;
}

int priority(char op) {
    if (op == '+' || op == '-') {
        return 1;
    } else if (op == '*' || op == '/') {
        return 2;
    } else {
        return 0;
    }
}

char *infix_to_postfix(char *infix) {
    Stack s;
    s.top = -1;
    char *postfix = (char*)malloc(sizeof(char) * MAX_STACK_SIZE);
    int i = 0, j = 0;

    while (infix[i] != '\0') {
        if (is_digit(infix[i])) {
            postfix[j++] = infix[i];
        } else if (infix[i] == '(') {
            push(&s, infix[i]);
        } else if (infix[i] == ')') {
            while (!is_empty(&s) && peek(&s) != '(') {
                postfix[j++] = pop(&s);
            }
            if (!is_empty(&s) && peek(&s) != '(') {
                printf("Invalid expression\n");
                return NULL;
            }
            pop(&s);
        } else {
            while (!is_empty(&s) && priority(peek(&s)) >= priority(infix[i])) {
                postfix[j++] = pop(&s);
            }
            push(&s, infix[i]);
        }
        i++;
    }

    while (!is_empty(&s)) {
        postfix[j++] = pop(&s);
    }
    postfix[j] = '\0';
    return postfix;
}

int evaluate(char *postfix) {
    Stack s;
    s.top = -1;
    int i = 0;

    while (postfix[i] != '\0') {
        if (is_digit(postfix[i])) {
            push(&s, postfix[i] - '0');
        } else {
            int op2 = pop(&s);
            int op1 = pop(&s);
            switch (postfix[i]) {
                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;
            }
        }
        i++;
    }

    return pop(&s);
}

int main() {
    char infix[MAX_STACK_SIZE];
    printf("Enter an infix expression: ");
    scanf("%s", infix);
    char *postfix = infix_to_postfix(infix);
    if (postfix != NULL) {
        printf("Postfix expression: %s\n", postfix);
        printf("Result: %d\n", evaluate(postfix));
    }
    return 0;
}

实验结果：

Enter an infix expression: (3+4)*5-6/2
Postfix expression: 34+5*62/-
Result: 29

Enter an infix expression: 2*(3+4)-5/2
Postfix expression: 234+*52/-
Result: 12

Enter an infix expression: (1+2)*(3+4)/(5+6)
Postfix expression: 12+34+*56+/
Result: 1