数据结构c语言四则运算

在C语言中，可以使用各种数据结构来实现四则运算。其中最常用的数据结构包括数组、链表和栈。

首先，可以使用数组来表示简单的四则运算表达式。比如可以将表达式转换成后缀表达式，然后利用数组来存储后缀表达式的元素，并通过栈来计算后缀表达式的值。这样就可以实现加减乘除的运算。

另外，还可以使用链表来表示四则运算表达式。可以将表达式转换成中缀表达式后，利用链表来存储中缀表达式的元素，并通过栈来计算中缀表达式的值。这样也可以实现加减乘除的运算。

此外，栈也是十分常用的数据结构来实现四则运算。可以利用栈来存储中缀表达式中的操作数和操作符，然后通过栈来计算中缀表达式的值。这种方法也可以实现加减乘除的运算，并且在实现中缀表达式转换成后缀表达式时十分方便。

总之，C语言中可以使用各种数据结构来实现四则运算，包括数组、链表和栈。通过合理地选择数据结构和算法，可以实现高效、灵活和简洁的四则运算功能。

相关问题

数据结构四则运算课程设计

数据结构四则运算课程设计是一个实现任意长度整数的加法和减法运算的演示程序。该设计利用双向循环链表作为数据结构来存储长整数，每个节点包含一个整形变量，范围是 -(2^15 - 1)~ (2^15 - 1)。该程序可以处理带小括号的中缀表达式，并按照中国对长整数的表示习惯，每四位一组，组间用逗号隔开进行输出。请注意，输入的四则表达式必须合法，并且操作数的有效数字长度不能超过15位。同时，正数可以省略前面的正号。<em>1</em><em>2</em><em>3</em>
#### 引用[.reference_title]
- *1* *3* [2020数据结构课程设计 超长整数四则运算（C语言+双向循环链表）](https://blog.csdn.net/qq_45572675/article/details/122245520)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}} ] [.reference_item]
- *2* [数据结构课程设计四则运算表达式求值（C语言版）](https://blog.csdn.net/aisebu7819/article/details/101517454)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}} ] [.reference_item]
[ .reference_list ]

c语言栈实现四则运算

栈是一种可以进行后进先出（Last In First Out，LIFO）操作的数据结构，可以用来实现四则运算的求值。以下是使用C语言实现栈来实现四则运算的示例代码：

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

#define MAX_SIZE 100

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

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

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

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

// 入栈操作
void push(Stack *s, int val) {
    if (is_full(s)) {
        printf("Stack overflow\n");
        exit(1);
    }
    s->data[++s->top] = val;
}

// 出栈操作
int pop(Stack *s) {
    if (is_empty(s)) {
        printf("Stack underflow\n");
        exit(1);
    }
    return s->data[s->top--];
}

// 获取栈顶元素
int top(Stack *s) {
    if (is_empty(s)) {
        printf("Stack underflow\n");
        exit(1);
    }
    return s->data[s->top];
}

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

// 计算两个数的结果
int calculate(int a, int b, char op) {
    switch (op) {
        case '+':
            return a + b;
        case '-':
            return a - b;
        case '*':
            return a * b;
        case '/':
            return a / b;
        default:
            printf("Invalid operator\n");
            exit(1);
    }
}

// 计算表达式的值
int evaluate(char *expr) {
    Stack operand_stack, operator_stack;
    init(&operand_stack);
    init(&operator_stack);

    while (*expr != '\0') {
        if (is_digit(*expr)) {
            int num = 0;
            while (is_digit(*expr)) {
                num = num * 10 + (*expr - '0');
                expr++;
            }
            push(&operand_stack, num);
        } else if (*expr == '(') {
            push(&operator_stack, '(');
            expr++;
        } else if (*expr == ')') {
            while (top(&operator_stack) != '(') {
                char op = pop(&operator_stack);
                int b = pop(&operand_stack);
                int a = pop(&operand_stack);
                int result = calculate(a, b, op);
                push(&operand_stack, result);
            }
            pop(&operator_stack);
            expr++;
        } else if (*expr == '+' || *expr == '-') {
            while (!is_empty(&operator_stack) && top(&operator_stack) != '(') {
                char op = pop(&operator_stack);
                int b = pop(&operand_stack);
                int a = pop(&operand_stack);
                int result = calculate(a, b, op);
                push(&operand_stack, result);
            }
            push(&operator_stack, *expr);
            expr++;
        } else if (*expr == '*' || *expr == '/') {
            while (!is_empty(&operator_stack) && (top(&operator_stack) == '*' || top(&operator_stack) == '/')) {
                char op = pop(&operator_stack);
                int b = pop(&operand_stack);
                int a = pop(&operand_stack);
                int result = calculate(a, b, op);
                push(&operand_stack, result);
            }
            push(&operator_stack, *expr);
            expr++;
        } else {
            printf("Invalid character\n");
            exit(1);
        }
    }

    while (!is_empty(&operator_stack)) {
        char op = pop(&operator_stack);
        int b = pop(&operand_stack);
        int a = pop(&operand_stack);
        int result = calculate(a, b, op);
        push(&operand_stack, result);
    }

    return top(&operand_stack);
}

int main() {
    char expr[MAX_SIZE];
    printf("Enter an expression: ");
    scanf("%s", expr);
    int result = evaluate(expr);
    printf("Result: %d\n", result);
    return 0;
}

在以上代码中，我们使用了两个栈来实现四则运算的求值。其中，`operand_stack` 用于存储操作数，`operator_stack` 用于存储运算符。具体的求值过程如下：

1. 从左到右遍历表达式的每个字符。

2. 如果字符是数字，则将其解析为整数，并将其压入 `operand_stack` 中。

3. 如果字符是左括号，则将其压入 `operator_stack` 中。

4. 如果字符是右括号，则不断弹出 `operator_stack` 的栈顶元素，直到遇到左括号为止。对于每个弹出的运算符，都从 `operand_stack` 中弹出两个操作数进行计算，将结果压入 `operand_stack` 中。

5. 如果字符是加号或减号，则不断弹出 `operator_stack` 的栈顶元素，直到遇到左括号或空栈为止。对于每个弹出的运算符，都从 `operand_stack` 中弹出两个操作数进行计算，将结果压入 `operand_stack` 中。最后将当前字符压入 `operator_stack` 中。

6. 如果字符是乘号或除号，则不断弹出 `operator_stack` 的栈顶元素，直到遇到加号、减号、左括号或空栈为止。对于每个弹出的运算符，都从 `operand_stack` 中弹出两个操作数进行计算，将结果压入 `operand_stack` 中。最后将当前字符压入 `operator_stack` 中。

7. 如果字符不是数字、左括号、右括号、加号、减号、乘号或除号，则报错并退出程序。

8. 遍历完整个表达式后，不断弹出 `operator_stack` 的栈顶元素，直到空栈为止。对于每个弹出的运算符，都从 `operand_stack` 中弹出两个操作数进行计算，将结果压入 `operand_stack` 中。

9. 最后，`operand_stack` 中剩下的唯一元素就是表达式的值。

以上就是使用栈来实现四则运算的示例代码。