反波兰表达式的转化和计算·示例代码

一、反波兰表达式的转化方法

1.设定运算符栈；

2.从左到右遍历中缀表达式的每个数字和运算符；

3.若当前字符是数字，则直接输出成为后缀表达式的一部分；

4.若当前字符为运算符，则判断其与栈顶运算符的优先级，若优先级大于栈顶运算符，则进栈；若优先级小于等于栈顶运算符，退出栈顶运算符成为后缀表达式的一部分，然后将当前运算符放入栈中，注意，这一步需要重复进行直到当前字符大于栈顶运算符；

5.若当前字符为“(”，进栈；

6.若当前字符为“)”，则从栈顶起，依次将栈中运算符出栈成为后缀表达式的一部分，直到碰到“(”。将栈中“(”出栈，不需要成为后缀表达式的一部分，然后继续扫描表达式直到最终输出后缀表达式为止。

7.最后要把栈中剩余的运算符按顺序全部弹出，加入到后缀表达式！！！

————————————————

版权声明：本文为CSDN博主「JAZHR」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

原文链接：https://blog.csdn.net/qq_43290883/article/details/125633103

二、反波兰表达式的转化·示例代码

该段代码用于将中缀表达式转化为后缀表达式

#include 
#include  
#define MAXSIZE_signStack 100
#define MAXSIZE_INPUT  1000
#define MAXSIZE_OUTPUT 1000

//中缀转后缀函数 
char signStack[MAXSIZE_signStack]; //操作符栈 
int signtop;   //操作符栈栈顶编号

char input[MAXSIZE_INPUT];     //中缀表达式 
char output[MAXSIZE_OUTPUT];   //后缀表达式 

//中缀转后缀函数以及其附属函数声明

//中缀表达式必须严格存储在input数组中
//后缀表达式必须严格存储在output数组中
//上述两数组的最大值由MAXSIZE_INPUT和MAXSIZE_OUTPUT定义，需要进行define
//需要定义操作符栈数组和操作符栈栈顶编号 
void anti_poland_tras(); 
void initStack(int* ptop); 
int isEmpty(int* ptop);
int isFull(int* ptop);
void Error(char *s);
void push_char(char *s,char item,int* ptop);
void pop_char(int* ptop);
int grade(char a);
//栈空判断函数和满栈判断函数可能与其它功能重复，请小心使用 

int main(void)
{
    //获取中缀表达式
    gets(input); 
    
    //进行转化为反波兰表达式的运算 
    anti_poland_tras();
    
    puts(output);    
}

//中缀转后缀函数 
void anti_poland_tras()
{
    //设定运算符栈
    initStack(&signtop);
    
    //操作符栈栈底以'#'垫底
    push_char(signStack,'#',&signtop);
    
    //遍历中缀表达式 
    int i;
    int j=0;
    //j用于记录output数组的长度-1 
    
    for (i=0;i='0'&&input[i]<='9')
        {
            //若当前字符为数字，则直接输出为后缀表达式 
            output[j++]=input[i]; 
        }
        else if (input[i]==' ')
        {
            //跳过潜在的空格 
            continue;
        }
        else if (input[i]=='(')
        {
            //如果是左引号，直接进栈 
            push_char(signStack,'(',&signtop);
            //读取符号要间隔
            output[j++]=' '; 
        }
        else if (input[i]==')')
        {
            //从栈顶起，依次将运算符出栈后成为后缀表达式的一部分，直到碰到'('。 
            while(signStack[signtop]!='(')
            {
                output[j++]=signStack[signtop];
                
                pop_char(&signtop);
            }     
            //'('出栈，但不写入后缀表达式 
            pop_char(&signtop);
            //读取符号要间隔
            output[j++]=' '; 
        }
        else
        {
            //当前字符优先级小于等于栈顶运算符，弹出栈顶运算符并输入至后缀表达式
            //重复此操作，直到当前字符优先级大于栈顶运算符 
            while(grade(input[i])<=grade(signStack[signtop]))
            {
                output[j++]=signStack[signtop]; 
                
                pop_char(&signtop);    
            }
            
            //当前字符优先级大于栈顶运算符，当前字符直接进栈 
            push_char(signStack,input[i],&signtop);
            //读取符号要间隔
            output[j++]=' '; 
        }
    }
    
    //最后弹出所有的剩余操作符 
    while (signtop>0)
    {
        output[j++]=signStack[signtop];
     
        pop_char(&signtop);
    }
} 

//建栈函数，参数是指向操作符栈顶编号的指针
void initStack(int* ptop)    
{
    *ptop=-1;
} 

//空栈判断函数，参数是指向操作符栈顶编号的指针
//如果为空栈返回1，否则返回0 
int isEmpty(int* ptop)     
{
    return *ptop==-1;
} 

//满栈判断函数，参数是指向操作符栈顶编号的指针
//如果为满栈返回1，否则返回0 
int isFull(int* ptop)
{
    return *ptop==MAXSIZE_signStack-1;
}

//报错信息函数 
void Error(char *s)
{
    printf("%s\n",s);
    
    exit(1);
}

//字符栈压栈函数，共有三个参数 
//第一个参数是指向栈数组第一个元素的指针
//第二个参数是要进栈的字符 
//第三个参数是指向操作符栈顶编号的指针 
void push_char(char *s,char item,int* ptop)   
{
    if (isFull(ptop))
    {
        Error("Stack overflow!");
    }
    else
    {
        s[++(*ptop)]=item;
    }
}

//字符栈弹出函数，共有一个参数 
//第一个参数是指向操作符栈顶编号的指针
void pop_char(int* ptop)
{
    if(isEmpty(ptop))
    {
        Error("Stack Empty!");
    }
    else
    {
        --(*ptop);
    }
}

//优先级判断函数，参数是被比较的字符 
int grade(char a)
{
    switch(a)
    {
        case '#':return 0;
        case '(':return 1;
        case '+':
        case '-':return 2;
        case '*':
        case '/':return 3;   
    }
    return -1;
}

三、反波兰表达式的计算方法

1.设定待计算的整数栈；

2.从左到右遍历后缀表达式的每个整数和运算符；

3.若当前字符是数字，则将连续的数字字符用sscanf函数压入真数栈，并且在之后遍历时，跳过这些字符；

4.若当前字符为运算符，则取整数栈最顶上的整数和次顶上的整数进行计算，并将这两者弹出栈，然后将计算结果压入栈中；（注意，若操作符为减号，则应该用次顶上的数字减去最顶上的数字；若操作符为除号，也同样处理）

5.最后栈中只剩下了一个整数，这个整数就是反波兰表达式计算的最终结果。

四、反波兰表达式的计算·示例代码

#include 
#include 

#define MAXSIZE_numStack 100
#define MAXSIZE_expression 1000

int numStack[MAXSIZE_numStack];  //后缀计算数字栈
int numtop;    //后缀计算数字栈栈顶编号

//后缀表达式计算函数及其附属函数的声明
int anti_poland_cal(char* expression); 
void initStack(int* ptop); 
int isEmpty(int* ptop);
int isFull1(int* ptop);
void Error(char *s);
void push_int(int *s,int item,int* ptop);
void pop_int(int* ptop);
 

char expression[MAXSIZE_expression];//待计算后缀表达式
 
 
 
int main(void)
{
    gets(expression);
    
    printf("%d",anti_poland_cal(expression));
    
    return  0;
}

//后缀表达式计算函数
int anti_poland_cal(char* expression)
{
    //设定计算数字栈
    initStack(&numtop);
    
    //遍历中缀表达式
    int i;
    
    int tmp;
    //tmp用于存储读取的数字 
    
    for (i=0;i='0'&&expression[i]<='9')
        {
            sscanf(expression+i,"%d",&tmp);
            
            push_int(numStack,tmp,&numtop);
            
            while (expression[i]>='0'&&expression[i]<='9')
            {
                i++;
            }
            
            i--;
            //因为每一轮for循环都会自动对i进行累加，所以要i-- 
        }
        else if (expression[i]=='+')
        {
            int tmp1,tmp2,result;
            //tmp1和tmp2分别用于存储栈顶和次顶的元素，result用于得出计算结果 
            tmp1=numStack[numtop];
            
            pop_int(&numtop);
            //取值后，直接弹出 
            tmp2=numStack[numtop];
            
            pop_int(&numtop);
            
            result=tmp1+tmp2;
            
            push_int(numStack,result,&numtop);
            //计算结果压入栈 
        }
        else if (expression[i]=='-')
        {
            int tmp1,tmp2,result;
            
            tmp1=numStack[numtop];
            
            pop_int(&numtop);
            
            tmp2=numStack[numtop];
            
            pop_int(&numtop);
            
            result=tmp2-tmp1;
            
            push_int(numStack,result,&numtop);
        }
        else if (expression[i]=='*')
        {
            int tmp1,tmp2,result;
            
            tmp1=numStack[numtop];
            
            pop_int(&numtop);
            
            tmp2=numStack[numtop];
            
            pop_int(&numtop);
            
            result=tmp2*tmp1;
            
            push_int(numStack,result,&numtop);
        }
        else if (expression[i]=='/')
        {
            int tmp1,tmp2,result;
            
            tmp1=numStack[numtop];
            
            pop_int(&numtop);
            
            tmp2=numStack[numtop];
            
            pop_int(&numtop);
            
            result=tmp2/tmp1;
            
            push_int(numStack,result,&numtop);
        }
    }
    
    return numStack[0]; 
    
}

//建栈函数，参数是指向操作符栈顶编号的指针
void initStack(int* ptop)    
{
    *ptop=-1;
} 

//空栈判断函数，参数是指向操作符栈顶编号的指针
//如果为空栈返回1，否则返回0 
int isEmpty(int* ptop)     
{
    return *ptop==-1;
} 

//满栈判断函数，参数是指向操作符栈顶编号的指针
//如果为满栈返回1，否则返回0 
int isFull1(int* ptop)
{
    return *ptop==MAXSIZE_numStack-1;
}

//报错信息函数 
void Error(char *s)
{
    printf("%s\n",s);
    
    exit(1);
}

//整数型压栈函数，共有三个参数 
//第一个参数是指向栈数组第一个元素的指针
//第二个参数是要进栈的整数 
//第三个参数是指向操作符栈顶编号的指针 
void push_int(int *s,int item,int* ptop)   
{
    if (isFull1(ptop))
    {
        Error("Stack overflow!");
    }
    else
    {
        s[++(*ptop)]=item;
    }
}

//整数型栈弹出函数，共有一个参数 
//第一个参数是指向操作符栈顶编号的指针
void pop_int(int* ptop)
{
    if(isEmpty(ptop))
    {
        Error("Stack Empty!");
    }
    else
    {
        --(*ptop);
    }
}

五、特别提醒

请来自航专的同学不要直接复制代码，会查重的！