自己编的中缀表达式转后缀表达式（Ｃ语言），供参考，指证

最新推荐文章于 2023-09-18 22:58:15 发布
最新推荐文章于 2023-09-18 22:58:15 发布
阅读量601 收藏 3
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ser_bad/article/details/46912153
版权

 

#include"stdio.h"
#include"malloc.h"
#include"string.h"
#include"stdlib.h"

#define MAX 100
char string1[MAX];
char string2[MAX];
typedef struct LNode {
    char a;
    struct LNode *next;
} StackNode;

typedef struct {
    StackNode *top;
} LinedkStack;

void InitStack(LinedkStack &S) {
    S.top = (StackNode *) malloc(sizeof(StackNode));
    S.top = 0;
}

void push(LinedkStack &S, char e) {
    StackNode *p;
    p = (StackNode *) malloc(sizeof(StackNode));
    p->a = e;
    p->next = NULL;
    p->next = S.top;
    S.top = p;
}

int pop(LinedkStack &S) {
    StackNode *p;
    char e;
    if (NULL != S.top) {
        p = S.top;
        e = p->a;
        S.top = p->next;
        free(p);
        return 1;
    } else
        return 0;
}

char read(LinedkStack &L) {
    char e;
    if (L.top != NULL) {
        e = L.top->a;
    } else {
        e = '#';
    }
    return e;
}

typedef struct {
    double data[MAX];
    int top;
} SeqStack;

void InitStack(SeqStack &S) {
    S.top = 0;
}

void SeqPush(SeqStack &S, double e) {
    if (S.top > MAX) {
        printf("栈已满!\n");
    } else
        S.data[S.top] = e;
    S.top++;
}

double SeqPop(SeqStack &S) {
    double e;
    if (S.top == 0) {
        printf("栈为空!\n");
    } else {
        S.top--;
        e = S.data[S.top];
    }
    return e;
}

int set(char e) {
    int p;
    switch (e) {
        case '#':
            p = 1;
            break;
        case '(':
            p = 2;
            break;
        case '+':
        case '-':
            p = 3;
            break;
        case '*':
        case '/':
        case '%':
            p = 4;
            break;
        case ')':
            p = 5;
            break;
        default:
            printf("你输入的符号不存在,请从新输入!\n");
            gets(string1);
            break;
    }
    return p;
}

void fix(char b[], char c[]) {
    LinedkStack L;
    char ch, ca;
    int i = 0, j = 0, k, d, m;
    InitStack(L);
    push(L, '#');
    m = strlen(b);
    ch = b[i];
    i++;
    for (; i <= m;) {
        ca = read(L);
        if (ch < '0' || ch > '9') {
            k = set(ch);
            d = set(read(L));
            if (k > d) {
                if (ch == ')') {
                    ca = read(L);
                    j--;
                    while (ca != '(') {
                        pop(L);
                        j++;
                        c[j] = ca;
                        j++;
                        c[j] = ',';
                        ca = read(L);
                    }
                    pop(L);
                    ch = b[i];
                    i++;
                    j++;
                } else {
                    push(L, ch);
                    ch = b[i];
                    i++;
                }
            } else {
                if (ch != '(') {
                    ca = read(L);
                    c[j] = ca;
                    j++;
                    c[j] = ',';
                    j++;
                    pop(L);
                    continue;
                }
                push(L, ch);
                ch = b[i];
                i++;
            }
        } else {
            while (ch >= '0' && ch <= '9') {
                c[j] = ch;
                j++;
                ch = b[i];
                i++;
            }
            c[j] = ',';
            j++;
        }
    }
    ca = read(L);
    while (ca != '#') {
        c[j] = ca;
        j++;
        c[j] = ',';
        j++;
        pop(L);
        ca = read(L);
    }
    c[--j] = '\0';
}

double cal(char b[]) {
    SeqStack S;
    InitStack(S);
    char ca[15];
    int i = 0, j = 0;
    double x1 = 0, x2 = 0, v;
    while (b[i] != '\0') {
        if (b[i] >= '0' && b[i] <= '9' && b[i] != ',') {
            j = 0;
            memset(ca, '\0', sizeof(ca));
            while (b[i] != ',') {
                ca[j] = b[i];
                i++;
                j++;
            }
            v = atol(ca);
            SeqPush(S, v);
        } else {
            v = 0;
            switch (b[i]) {
                case ',':
                    break;
                case '+':
                    x1 = SeqPop(S);
                    x2 = SeqPop(S);
                    v = x2 + x1;
                    SeqPush(S, v);
                    break;
                case '-':
                    x1 = SeqPop(S);
                    x2 = SeqPop(S);
                    v = x2 - x1;
                    SeqPush(S, v);
                    break;
                case '*':
                    x1 = SeqPop(S);
                    x2 = SeqPop(S);
                    v = x2 * x1;
                    SeqPush(S, v);
                    break;
                case '/':
                    x1 = SeqPop(S);
                    x2 = SeqPop(S);
                    if (x1 == 0.0) {
                        printf("出现除0错误,请从新输入!\n");
                        gets(string1);
                    } else {
                        v = x2 / x1;
                        SeqPush(S, v);
                    }
                    break;
                case '%':
                    int x1 = SeqPop(S);
                    int x2 = SeqPop(S);
                    v = x2 % x1;
                    SeqPush(S, v);
                    break;
            }
            i++;
        }
    }
    v = SeqPop(S);
    return v;
}

void main() {
    int n, m;
    double f;
    char sr[MAX];
    printf("请输入中缀表达式:\n");
    gets(string1);
    m = strlen(sr);
    for (n = 0; n <= m; n++) {
        sr[n] = string1[n];
        if (string1[n] == '%' && string1[n + 1] == '-') {
            printf("求余号后面有减号,请从新输入!\n");
            gets(string1);
        }
    }
    fix(string1, string2);
    printf("后缀表达式:\n%s\n", string2);
    f = cal(string2);
    printf(" 计算结果:\n%lf\n", f);
}

 

SerBad
关注
中缀表达式转后缀表达式代码
mzy1711231996的博客
07-19 235
中缀表达式转后缀表达式 分析图在上上上…博客里的分析里 分析思路图连接 这里是代码实现 private static List<String> getHouzhuiExpression(List<String> resList) { Stack<String> s1 = new Stack<String>();// 符号栈 ArrayList<String> s2 = new ArrayList<String>();// 数栈
中缀表达式转后缀表达式思想
TerryLMay
11-19 2336
这个思想对于算数表达式qiu'zhi 中缀表达式到后缀表达式的转换 　 　要把表达式从中缀表达式的形式转换成用后缀表示法表示的等价表达式，必须了解操作符的优先级和结合性。优先级或者说操作符的强度决定求值顺序；优先级高 的操作符比优先级低的操作符先求值。 如果所有操作符优先级一样，那么求值顺序就取决于它们的结合性。操作符的结合性定义了相同优先级操作符组合的顺序（从右至左或从左至右）。  转换过
中缀表达式转后缀表达式程序C语言版
10-21
用C语言写的中缀转后缀程序...简单易懂适合初学数据结构的人参考
数据结构与算法：中缀表达式转后缀表达式【C语言实现】
weixin_44270855的博客
10-10 483
最近，数据结构课上分组合作完成的实验题，我用顺序栈实现，小伙伴用了链栈实现，虽然很简单，但是我们也努力了，很不错的一次合作！ 对于运算符的比较： 1.如果当前元素的优先级高于栈顶元素的优先级、或者栈顶元素是左括号而当前入栈元素又不是右括号，都直接入栈 2.如果当前元素是右括号就意味着栈里面肯定有左括号，直接输出到左括号为止（不过左括号和右括号本身是不能被输出的，出栈就可以了）），右括号的作用就是...
【C语言】中缀表达式转后缀表达式
最新发布
weixin_55582076的博客
09-18 846
【代码】【C语言】中缀表达式转后缀表达式。
[C语言]中缀表达式转后缀表达式
CRAJA的blog
04-01 236
中缀转后缀
c语言实现中缀表达式转后缀并求值
04-09
c语言实现中缀表达式转后缀表达式并求得计算结果，用顺序栈结构。 当输入者输入错误信息的时候需要报错，并说明错误的种类。
C++实现中缀表达式转后缀表达式
08-19
C++实现中缀表达式转后缀表达式 本文主要介绍了C++实现中缀表达式转后缀表达式的方法，包括思路和实现程序。中缀表达式转后缀表达式是计算机科学中的一种常见操作，用于将中缀表达式转换为后缀表达式，以便于计算和...
中缀表达式变后缀表达式（c语言）
11-10
可以实现将一个以#号结束的中缀表达式转换为后缀表达式
C语言实现中缀表达式转换为后缀表达式
12-20
本文实例为大家分享了C语言实现中缀表达式转后缀表达式的具体代码，供大家参考，具体内容如下 中缀表达式转换为后缀表达式（思路） 1.创建栈 2.从左向右顺序获取中缀表达式 a.数字直接输出 b.运算符 情况一：遇到左括号直接入栈，遇到右括号将栈中左括号之后入栈的运算符全部弹栈输出，同时左括号出栈但是不输出。 情况二：遇到乘号和除号直接入栈，直到遇到优先级比它更低的运算符，依次弹栈。 情况三：遇到加号和减号，如果此时栈空，则直接入栈，否则，将栈中优先级高的运算符依次弹栈（注意：加号和减号属于同一个优先级，所以也依次弹栈）直到栈空或则遇到左括号为止，停止弹栈。（因为左括号要匹配右括号时才弹出）。
表达式的转换 中缀表达式转化为后缀表达式 C语言编程
06-04
表达式的转换中缀表达式转化为后缀表达式 C语言编程
C++中缀表达式转后缀表达式的方法
08-19
C++中缀表达式转后缀表达式的方法主要介绍了C++中缀表达式转后缀表达式的方法，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。 中缀表达式是一种常见的表达式形式，例如：A+B*C...
C++利用栈实现中缀表达式转后缀表达式
12-20
在计算机科学中，中缀表达式是我们日常生活中最常见的表达式形式，例如...总的来说，通过这个实例，我们可以了解到如何在C++中利用栈来解决实际的计算问题，加深了对栈数据结构和中缀表达式转后缀表达式算法的理解。
中缀表达式转后缀表达式C语言实现
u012011912的博客
09-11 1944
【代码】中缀表达式转后缀表达式C语言实现。
中缀表达式转后缀表达式 c语言实现
owlNo46的博客
10-31 1743
栈我就是用的上一篇写的那个链栈， 可能有些栈的方法并没有用到 首先中缀表达式转后缀表达式（逆波兰表达式）需要用到一个栈来辅助实现。下面有几条规则（抄的网友的，哈哈哈自己也重新整理了一下） 具体转换方式: 首先的优先级我把它分为( > ÷ > × > - > + 将字符串从左到右进行遍历 运算数,直接输出. 左括号,直接压入堆栈,(括号是最高优先级,无需比较)(入栈后优先级降到最低,确保其他符号正常入栈) 右括号,(意味着括号已结束)不断弹出栈顶运算符并输出直到遇到左...
中缀转后缀表达式（C语言实现）
YouYang_Wang的博客
04-11 2076
实现效果 源码 #include<stdio.h> #include<string.h> //创建栈 typedef struct node { char s[1000]; int top; }Stack; //判断符号的函数 int weight(char ch, int flag) { if(ch=='+'||ch=='-') return 1; if(ch=='*'||ch=='/') return 2; if(ch=='('&&fla
中缀表达式转后缀表达式——c语言栈实现
chabuduoxs的博客
09-21 5347
题意 假定运算符集合为{ +、-、*、/、（、）}，利用栈将输入的中缀表达式转换成等价的后缀表达式，并输出。 输入格式: 输入一个字符串表示的中缀表达式（以“#”结束），其中每个操作数用一个小写字母表示。 输出格式: 将对应的后缀表达式输出。 输入样例: a+b-a*((c+d)/e-f)+g# 结尾无空行 输出样例: ab+acd+e/f-*-g+ 结尾无空行 大体思路 所谓后缀表达式，又名逆波兰表达式。 计算机遇见后缀表达式的操作： 从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶
中缀表达式转后缀表达式的C语言代码
05-09
中缀表达式转后缀表达式的C语言代码可以通过使用栈来实现。具体步骤如下： 1. 从左到右扫描中缀表达式的每个元素。 2. 如果当前元素是操作数，直接输出到后缀表达式中。 3. 如果当前元素是左括号，将其压入栈中。 4. 如果当前元素是右括号，将栈中的元素弹出并输出到后缀表达式中，直到遇到左括号。 5. 如果当前元素是操作符，比较其与栈顶操作符的优先级，如果当前操作符优先级高于栈顶操作符，将其压入栈中。 6. 如果当前操作符优先级低于或等于栈顶操作符，将栈顶操作符弹出并输出到后缀表达式中，然后再次比较当前操作符与新的栈顶操作符的优先级，直到当前操作符可以被压入栈中。 7. 重复步骤1~6，直到中缀表达式扫描完毕。 8. 如果栈中还有操作符，依次弹出并输出到后缀表达式中。 下面是中缀表达式转后缀表达式的C语言代码实现： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_SIZE 100 typedef struct { char data[MAX_SIZE]; int top; } 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, char c) { if (is_full(s)) { printf("Stack Overflow\n"); exit(1); } s->data[++s->top] = c; } // 出栈 char pop(Stack *s) { if (is_empty(s)) { printf("Stack Underflow\n"); exit(1); } return s->data[s->top--]; } // 获取栈顶元素 char peek(Stack *s) { if (is_empty(s)) { printf("Stack Underflow\n"); exit(1); } return s->data[s->top]; } // 判断是否为操作符 int is_operator(char c) { return c == '+' || c == '-' || c == '*' || c == '/'; } // 获取操作符优先级 int get_precedence(char c) { if (c == '+' || c == '-') { return 1; } else if (c == '*' || c == '/') { return 2; } else { return 0; } } // 中缀表达式转后缀表达式 char* infix_to_postfix(char *infix) { Stack s; init(&s); int length = strlen(infix); char *postfix = (char*)malloc(sizeof(char) * length); int j = 0; for (int i = 0; i < length; i++) { char c = infix[i]; if (is_operator(c)) { while (!is_empty(&s) && is_operator(peek(&s)) && get_precedence(peek(&s)) >= get_precedence(c)) { postfix[j++] = pop(&s); } push(&s, c); } else if (c == '(') { push(&s, c); } else if (c == ')') { while (!is_empty(&s) && peek(&s) != '(') { postfix[j++] = pop(&s); } pop(&s); } else { postfix[j++] = c; } } while (!is_empty(&s)) { postfix[j++] = pop(&s); } postfix[j] = '\0'; return postfix; } int main() { char infix[MAX_SIZE]; printf("Enter an infix expression: "); fgets(infix, MAX_SIZE, stdin); char *postfix = infix_to_postfix(infix); printf("Postfix expression: %s\n", postfix); free(postfix); return 0; } ``` 注意，以上代码中的`fgets()`函数可以保证输入不会超过`MAX_SIZE`的限制。如果使用`scanf()`函数，需要对输入进行有效性检查，以避免缓冲区溢出等问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值