用C语言创建一个栈创建顺序栈的结构、出栈、入栈、判栈空、栈满并实现加、减、乘、除功能并输入一中缀表达式转换为后缀表达式并计算其值

好的，我来为您解答。

首先，我们需要定义顺序栈的结构体：

#define MAXSIZE 100  // 栈的最大容量

typedef struct {
    int data[MAXSIZE];  // 栈的数据域
    int top;  // 栈顶指针
} SqStack;

其中，`data`数组用于存储栈中的元素，`top`指针指向栈顶元素的下标。

接下来，我们可以实现栈的入栈、出栈、判栈空、栈满等操作：

// 初始化栈
void initStack(SqStack *s) {
    s->top = -1;  // 栈顶指针初始化为-1，表示空栈
}

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

// 判断栈满
int isFull(SqStack *s) {
    return s->top == MAXSIZE - 1;
}

// 入栈
int push(SqStack *s, int x) {
    if (isFull(s)) {  // 栈满
        return 0;
    }
    s->top++;  // 栈顶指针加1
    s->data[s->top] = x;  // 将元素x入栈
    return 1;
}

// 出栈
int pop(SqStack *s, int *x) {
    if (isEmpty(s)) {  // 栈空
        return 0;
    }
    *x = s->data[s->top];  // 取出栈顶元素
    s->top--;  // 栈顶指针减1
    return 1;
}

现在我们可以实现加、减、乘、除四种运算：

// 加法
int add(int a, int b) {
    return a + b;
}

// 减法
int sub(int a, int b) {
    return a - b;
}

// 乘法
int mul(int a, int b) {
    return a * b;
}

// 除法
int div(int a, int b) {
    return a / b;
}

接下来，我们需要将中缀表达式转换为后缀表达式。这里我们可以借助栈来实现。具体过程如下：

1. 从左到右扫描中缀表达式；
2. 遇到操作数时，直接输出（或存入数组）；
3. 遇到运算符时，比较其与栈顶运算符的优先级：
1. 如果栈为空或栈顶运算符为左括号“（”，则直接将该运算符入栈；
2. 如果该运算符优先级比栈顶运算符优先级高，也将其入栈；
3. 否则，将栈顶运算符弹出并输出（或存入数组），再次转到（3）与新的栈顶运算符比较优先级，直到运算符入栈；
4. 遇到括号时：
1. 如果是左括号“（”，直接入栈；
2. 如果是右括号“）”，则依次弹出栈顶运算符并输出（或存入数组），直到遇到左括号为止，此时将左括号弹出但不输出（或不存入数组）。

根据上述算法，我们可以实现中缀表达式转换为后缀表达式：

int isOperator(char c) {
    return c == '+' || c == '-' || c == '*' || c == '/';
}

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

void infixToPostfix(char *infix, char *postfix) {
    SqStack s;
    initStack(&s);
    int i = 0, j = 0;
    while (infix[i] != '\0') {
        if (!isOperator(infix[i]) && infix[i] != '(' && infix[i] != ')') {
            postfix[j++] = infix[i];
        } else if (infix[i] == '(') {
            push(&s, infix[i]);
        } else if (infix[i] == ')') {
            char c;
            while (pop(&s, &c) && c != '(') {
                postfix[j++] = c;
            }
        } else {
            char c;
            while (!isEmpty(&s) && peek(&s, &c) && priority(c) >= priority(infix[i])) {
                pop(&s, &c);
                postfix[j++] = c;
            }
            push(&s, infix[i]);
        }
        i++;
    }
    while (!isEmpty(&s)) {
        char c;
        pop(&s, &c);
        postfix[j++] = c;
    }
    postfix[j] = '\0';
}

最后，我们可以实现后缀表达式的计算。具体过程如下：

1. 从左到右扫描后缀表达式；
2. 遇到操作数时，将其压入栈中；
3. 遇到运算符时，弹出栈顶的两个操作数，并将运算结果压入栈中。

根据上述算法，我们可以实现后缀表达式的计算：

int calculate(char *postfix) {
    SqStack s;
    initStack(&s);
    int i = 0;
    while (postfix[i] != '\0') {
        if (!isOperator(postfix[i])) {
            push(&s, postfix[i] - '0');
        } else {
            int b, a;
            pop(&s, &b);
            pop(&s, &a);
            switch (postfix[i]) {
                case '+': push(&s, add(a, b)); break;
                case '-': push(&s, sub(a, b)); break;
                case '*': push(&s, mul(a, b)); break;
                case '/': push(&s, div(a, b)); break;
            }
        }
        i++;
    }
    int result;
    pop(&s, &result);
    return result;
}

完整代码如下：