PTA 表达式转换

最新推荐文章于 2025-05-17 13:15:27 发布

原创最新推荐文章于 2025-05-17 13:15:27 发布 · 2k 阅读

7 ·

CC 4.0 BY-SA版权

C 专栏收录该内容

30 篇文章

订阅专栏

本文介绍了一个程序设计案例，该程序能够将中缀表达式转换为后缀表达式，通过使用栈来实现运算符的优先级处理，适用于基本的算术运算。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

3-1 表达式转换

算术表达式有前缀表示法、中缀表示法和后缀表示法等形式。日常使用的算术表达式是采用中缀表示法，即二元运算符位于两个运算数中间。请设计程序将中缀表达式转换为后缀表达式。

输入格式:
输入在一行中给出不含空格的中缀表达式，可包含+、-、*、\以及左右括号()，表达式不超过20个字符。

输出格式:
在一行中输出转换后的后缀表达式，要求不同对象（运算数、运算符号）之间以空格分隔，但结尾不得有多余空格。

输入样例:

2+3*(7-4)+8/4

输出样例:

2 3 7 4 - * + 8 4 / +

Code:

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

//测试点
//2: ((2+3)*4-(8+2))/5    2 3 + 4 * 8 + - 5 /
//3: 1314+25.5*12         1314 25.5 12 * +

struct fuhao {
    char symbol[30];
    int t;
};

void Symbol_YZ(struct fuhao *s, char c)  //压入符号栈 
{
    s->t ++;
    s->symbol[s->t] = c;
}

char Symbol_CZ(struct fuhao *s)  //符号栈出栈 
{
    char c;
    c = s->symbol[s->t]; 
    s->t --;

    return c;
}

char Symbol_DZ(struct fuhao *s)  //读符号栈栈顶元素 
{
    char c = s->symbol[s->t];

    return c;
}

int judge(char c)
{
    int j;
    if(c == '(') {
        j = 1;
    }
    else if(c == '+' || c == '-') {
        j = 2;
    }
    else if(c == '*' || c == '/') {
        j = 3;
    }
    else if(c == ')') {
        j = 4;
    }

    return j;
}

int main(void)
{
    struct fuhao Symbol;
    Symbol.t = -1;
    char s[30];
    char v[30] = {0};
    int i = 0, k = 0, cnt = 0, flag = 1;
    gets(s);
    for(i = 0; s[i] != '\0'; i ++) {
        if((s[i] == '+' || s[i] == '-') && (!i || s[i-1] == '(') || s[i] >= '0' && s[i] <= '9') {
            if(s[i] != '+') {
                if(flag == 0) {
                    putchar(' ');
                    flag = 1; 
                }
                putchar(s[i]);
            }
            while(s[i+1] == '.' || s[i+1] >= '0' && s[i+1] <= '9') {
                if(flag == 0) {
                    putchar(' ');
                    flag = 1; 
                }
                putchar(s[++i]);
            }
            flag = 0;
        }
        else {
            if(judge(s[i]) == 1 || Symbol.t == -1) {  //当前符号为'('或符号栈为空 
                    Symbol_YZ(&Symbol, s[i]);  //进栈     
            }
            else if(judge(s[i]) == 4) {  //如果当前符号为')' 
                while(Symbol_DZ(&Symbol) != '(') { //循环出栈直到遇到'('
                    if(flag == 0) {
                        putchar(' ');
                        flag = 1; 
                    }
                    putchar(Symbol_CZ(&Symbol));
                    flag = 0;
                }
                Symbol_CZ(&Symbol); //让符号'('出栈 
            }
            else if(judge(Symbol_DZ(&Symbol)) < judge(s[i])) {  //如果栈顶元素优先级小于当前符号
                Symbol_YZ(&Symbol, s[i]);   //压入符号栈 
            }
            else if(judge(Symbol_DZ(&Symbol)) >= judge(s[i])) { //如果栈顶元素优先级大于或等于当前符号 
                while(Symbol.t > -1 && Symbol_DZ(&Symbol) != '(') { //循环出栈，直到栈底或者遇到'(' 
                    if(flag == 0) {
                        putchar(' ');
                        flag = 1; 
                    }
                    putchar(Symbol_CZ(&Symbol));
                    flag = 0;
                }
                Symbol_YZ(&Symbol, s[i]);
            }
        }
    }    
    while(Symbol.t > -1) {  //循环出栈
        if(flag == 0) {
            putchar(' ');
            flag = 1; 
        }
        putchar(Symbol_CZ(&Symbol));
        flag = 0;
    } 

    return 0;
}