中缀表达式转后缀表达式

最新推荐文章于 2024-08-08 21:58:59 发布

Asssshzy

最新推荐文章于 2024-08-08 21:58:59 发布

阅读量141

点赞数

分类专栏：笔记文章标签：数据结构

本文链接：https://blog.csdn.net/Asssshzy/article/details/114002768

版权

笔记专栏收录该内容

30 篇文章 0 订阅

订阅专栏

该博客介绍了一个使用C语言编写的程序，该程序能够处理中缀表达式，并将其转换为后缀表达式（逆波兰表示法）。程序通过栈操作处理运算符的优先级，实现了加减乘除及括号的正确处理。它能够读取输入的中缀表达式，然后输出简化后的后缀表达式，这对于理解和实现计算表达式的算法非常有帮助。

摘要由CSDN通过智能技术生成

输入样例:
(a+b)c
输出样例:
ab+c

#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>
#include<assert.h>
#include<malloc.h>
#include <cstdio>

#define TRUE 1
#define FALSE 0
#define  OK  1
#define  ERROR  0
#define  OVERFLOW -2

#define MAXBUFFER 10000
#define STACK_INIT_SIZE   100       //存储空间初始分配
#define STACKINCREMENT  10       //存储空间分配增量
typedef int Status;
typedef char SElemType;
typedef struct
{
    SElemType *base;
    SElemType *top;
    int stacksize;
} SqStack;


Status InitStack(SqStack &s)//建立空栈
{
    s.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    if (!s.base)
        exit(OVERFLOW);            //存储分配失败
    s.top=s.base;
    s.stacksize =STACK_INIT_SIZE;
    return OK;
}

Status PushStack(SqStack &s,SElemType e)
{
    //插入元素e为新的栈顶元素
    if(s.top-s.base>=s.stacksize)
    {
        //栈满,追加存储空间
        s.base = (SElemType*)realloc(s.base, (s.stacksize+STACKINCREMENT)*sizeof(SElemType));
        if(!s.base)
            exit(OVERFLOW);           //存储分配失败
        s.top = s.base + s.stacksize;
        s.stacksize +=STACKINCREMENT;
    }
    *s.top++=e;
    return OK;
}

int StackLength(SqStack S)
{
    return (S.top - S.base);
}

Status PopStack(SqStack &s,SElemType &e)//出栈
{
    if(s.top==s.base)
        return ERROR;
    e=*--s.top;
    return OK;
}

Status GetTop(SqStack s, SElemType &e)//获得栈顶元素
{
    if(s.top==s.base)
        return ERROR;
    e=*(s.top-1);
    return OK;
}

int main()
{
    SqStack S;
    SElemType e;
    InitStack(S);
    char ch;
    scanf("%c",&ch);

    while(ch!='\n')
    {
        if((ch>='0'&&ch<='9')||(ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z'))
        {
            /*过滤数字字符，直接输出，直到下一位不是数字字符打印空格跳出循环 */
            printf("%c",ch);

        }

        /*加减运算符优先级最低，如果栈顶元素为空则直接入栈，否则将栈中存储
        的运算符全部弹栈，如果遇到左括号则停止，将弹出的左括号重新压栈，因为左
        括号要和右括号匹配时弹出，这个后面单独讨论。弹出后将优先级低的运算符压入栈中*/
        if(ch=='+'||ch=='-')
        {
            if(!StackLength(S))//如果栈为空，直接入栈
                PushStack(S,ch);
            else//将栈内元素弹出，如果是左括号，再将它压入栈
            {
                do
                {
                    PopStack(S,e);
                    if(e=='(')
                        PushStack(S,e);
                    else
                        printf("%c",e);
                }
                while(StackLength(S)&&e!='(');

                PushStack(S,ch);//将+-入栈
            }
        }
        /*当遇到右括号是，把括号里剩余的运算符弹出，直到匹配到左括号为止
        左括号只弹出不打印（右括号也不压栈）*/
        else if(ch==')')
        {
            PopStack(S,e);
            while(e!='(')
            {
                printf("%c",e);
                PopStack(S,e);
            }
            /*do{
                PopStack(S,e);PopStack(S,e2);
                if(e=='+'||e=='-')
                    {PushStack(S,e);PushStack(S,e2);}
                else
                    {PushStack(S,e2);PushStack(S,e);}
            }while(StackLength(S)&&e!='(');*/
        }
        /*乘、除、左括号都是优先级高的，直接压栈*/
        else if(ch=='*'||ch=='/'||ch=='('||ch=='%')
        {

            if(!GetTop(S,e))//如果栈为空，入栈
                PushStack(S,ch);
            else if(ch!='(')
                if(e=='*'||e=='/'||e=='%')//如果栈内元素的优先级与当前比较的一样，弹出栈内元素，再入栈
                {
                    PopStack(S,e);
                    printf("%c",e);
                    PushStack(S,ch);//将当前元素入栈
                }
                else
                    PushStack(S,ch);//如果栈内元素优先级低，入栈
            else//如果是左括号，入栈
                PushStack(S,ch);
        }
        scanf("%c",&ch);

    }
    /*最后把栈中剩余的运算符依次弹栈打印*/
    while(StackLength(S))
    {
        PopStack(S,e);
        printf("%c",e);
    }

    return 0;
}