c语言，用户从键盘输入一个算术表达式，数字都是十进制整型（必须支持负数），运算符支持+-*/()。不用结构体

可以考虑用栈来实现算术表达式的计算。具体步骤如下：

1. 声明一个字符型数组，用来存储用户输入的算术表达式。

2. 声明一个整型栈，用来存储数字和运算符。

3. 对字符型数组进行遍历，依次处理每个字符：

- 如果是数字字符，则将其转换为整型数字并入栈。

- 如果是运算符，则根据其优先级进行处理：

- 如果当前运算符的优先级高于栈顶运算符的优先级，则将当前运算符入栈。

- 否则，弹出栈顶运算符和两个数字，进行运算，并将结果入栈，直到当前运算符的优先级高于栈顶运算符的优先级为止。

- 如果是左括号，则直接入栈。

- 如果是右括号，则弹出栈顶元素和两个数字，进行运算，并将结果入栈，直到遇到左括号为止。

4. 最终栈中只剩下一个元素，即为表达式的计算结果。

下面是代码实现：

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

#define MAX_EXPR_LEN 100

typedef struct {
    int *data;
    int top;
} Stack;

Stack *createStack(int capacity) {
    Stack *s = (Stack *)malloc(sizeof(Stack));
    s->data = (int *)malloc(sizeof(int) * capacity);
    s->top = -1;
    return s;
}

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

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

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

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

int isFull(Stack *s, int capacity) {
    return s->top == capacity - 1;
}

int priority(char op) {
    switch (op) {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        case '(':
        case ')':
            return 0;
        default:
            return -1;
    }
}

int evaluate(char *expr, int len) {
    Stack *nums = createStack(len / 2 + 1);
    Stack *ops = createStack(len / 2);

    for (int i = 0; i < len; i++) {
        if (isdigit(expr[i])) {
            int num = 0, j = i;
            while (j < len && isdigit(expr[j])) {
                num = num * 10 + (expr[j] - '0');
                j++;
            }
            i = j - 1;
            push(nums, num);
        } else if (expr[i] == '+' || expr[i] == '-' || expr[i] == '*' || expr[i] == '/') {
            while (!isEmpty(ops) && priority(expr[i]) <= priority(top(ops))) {
                int op = pop(ops), b = pop(nums), a = pop(nums);
                switch (op) {
                    case '+':
                        push(nums, a + b);
                        break;
                    case '-':
                        push(nums, a - b);
                        break;
                    case '*':
                        push(nums, a * b);
                        break;
                    case '/':
                        push(nums, a / b);
                        break;
                }
            }
            push(ops, expr[i]);
        } else if (expr[i] == '(') {
            push(ops, expr[i]);
        } else if (expr[i] == ')') {
            while (!isEmpty(ops) && top(ops) != '(') {
                int op = pop(ops), b = pop(nums), a = pop(nums);
                switch (op) {
                    case '+':
                        push(nums, a + b);
                        break;
                    case '-':
                        push(nums, a - b);
                        break;
                    case '*':
                        push(nums, a * b);
                        break;
                    case '/':
                        push(nums, a / b);
                        break;
                }
            }
            pop(ops);
        }
    }

    while (!isEmpty(ops)) {
        int op = pop(ops), b = pop(nums), a = pop(nums);
        switch (op) {
            case '+':
                push(nums, a + b);
                break;
            case '-':
                push(nums, a - b);
                break;
            case '*':
                push(nums, a * b);
                break;
            case '/':
                push(nums, a / b);
                break;
        }
    }

    return pop(nums);
}

int main() {
    char expr[MAX_EXPR_LEN];
    printf("Enter an arithmetic expression: ");
    fgets(expr, MAX_EXPR_LEN, stdin);
    int len = 0;
    while (expr[len] != '\0') {
        len++;
    }
    printf("Result: %d\n", evaluate(expr, len));
    return 0;
}