算术表达式的转换

最新推荐文章于 2020-10-23 23:21:25 发布

PearlOOO

最新推荐文章于 2020-10-23 23:21:25 发布

阅读量245

点赞数

分类专栏：栈与队列

本文链接：https://blog.youkuaiyun.com/acher66/article/details/52088574

版权

栈与队列专栏收录该内容

18 篇文章

订阅专栏

算术表达式的转换

Time Limit: 1000MS Memory limit: 65536K

题目描述

小明在学习了数据结构之后，突然想起了以前没有解决的算术表达式转化成后缀式的问题，今天他想解决一下。

因为有了数据结构的基础小明很快就解出了这个问题，但是他突然想到怎么求出算术表达式的前缀式和中缀式呢？小明很困惑。聪明的你帮他解决吧。

输入

输入一算术表达式，以\'#\'字符作为结束标志。（数据保证无空格,只有一组输入）

输出

输出该表达式转换所得到的前缀式中缀式后缀式。分三行输出，顺序是前缀式中缀式后缀式。

示例输入

a*b+(c-d/e)*f#

示例输出

+*ab*-c/def
a*b+c-d/e*f
ab*cde/-f*+

前缀规律：

1) 设立操作符栈OPTR，结果栈RESULT；

2) 从右向左遍历，若当前字符是操作数，则直接发送给RESULT栈；

3) 若当前运算符的优先数高于等于栈顶运算符，则进OPTR栈；

4) 否则，退出栈顶运算符发送给RESULT栈；

5) “）” 对它之前后的运算符起隔离作用，“（”可视为自相应右括弧开始的表达式的结束符。(即读到右括号时总是将它压入OPTR栈中,读到左括号时，将靠近栈顶的第一个右括号上面的运算符全部依次弹出，送至RESULT栈后，再丢弃右括号。 )

后缀规律：

1) 设立操作符栈；

2) 若当前字符是操作数，则直接发送给后缀式；

3) 若当前运算符的优先数高于栈顶运算符，则进栈；

4) 否则，退出栈顶运算符发送给后缀式；

5) “(” 对它之前后的运算符起隔离作用，“)”可视为自相应左括弧开始的表达式的结束符。(即读到左括号时总是将它压入栈中，读到右括号时，将靠近栈顶的第一个左括号上面的运算符全部依次弹出，送至输出队列后，再丢弃左括号。 )

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define stackmax 10000
#define stacknum 10000
typedef int elemtype;
typedef struct
{
    elemtype *base;
    elemtype *top;
    int stacksize;
} sqstack;
int initstack(sqstack &s)
{
    s.base = (elemtype *)malloc(stackmax * sizeof(elemtype));
    if(!s.base) exit(0);
    s.top = s.base;
    s.stacksize = stackmax;
}
char push(sqstack &s, char e)
{
    if(s.top - s.base > s.stacksize)
    {
        s.base = (elemtype *)realloc(s.base,(s.stacksize+stacknum) * sizeof(elemtype));
        if(!s.base) exit(0);
        s.top = s.base + s.stacksize;
        s.stacksize += stacknum;
    }
    *s.top++=e;
}
int pop(sqstack &s)
{
    if(s.top==s.base) return 0;
    s.top--;
    return 1;
}
char gettop(sqstack &s)
{
    if(s.top == s.base) return 0;
    char e = *(s.top-1);
    return e;
}

int stackempty(sqstack &s)
{
    if(s.top == s.base)
        return 1;
    else
        return 0;
}

int cmp(char c)//用于比较优先级
{
    if (c=='+'||c=='-')
        return 1;
    if (c=='*'||c=='/')
        return 2;
    if (c=='(')
        return 3;
    if (c==')')
        return 4;
}
char lasttranslate(sqstack &s, char c[])
{
    int n=strlen(c);
    int i;
    for(i=0; i<n; i++)
    {
        if (c[i]>='a'&&c[i]<='z')
            printf("%c", c[i]);
        else
        {
            if(c[i]!='#')
            {
                if(stackempty(s))
                {
                    push(s, c[i]);
                }

else
{

                    if(cmp(c[i])>cmp(gettop(s)))
                    {
                        if(c[i]==')')
                        {
                            while(gettop(s)!='(')
                            {
                                printf("%c", *(s.top-1));
                                pop(s);
                            }

                            pop(s);
                        }
                        else
                        {
                            push(s, c[i]);
                        }
                    }
                    else
                    {
                        if(gettop(s)=='(')
                            push(s, c[i]);
                        else
                        {
                            printf("%c", gettop(s));
                            pop(s);
                            push(s,c[i]);
                        }
                    }

                }
            }
        }

}

char pretranslate(sqstack &s1, sqstack &s2, char c[])
{
    int n=strlen(c);
    int i;
    for(i=n-2; i>=0; i--)
    {
        if (c[i]>='a'&&c[i]<='z')
            push(s1, c[i]);
        else

            if(stackempty(s2))
            {
                push(s2, c[i]);
            }

else
{

                if(cmp(c[i])>=cmp(gettop(s2)))
                {
                    if(c[i]=='(')
                    {
                        while(gettop(s2)!=')')
                        {
                            push(s1, *(s2.top-1));
                            pop(s2);
                        }

                        pop(s2);
                    }
                    else
                    {
                        push(s2, c[i]);
                    }
                }
                else
                {
                    if(gettop(s2)==')')
                        push(s2, c[i]);
                    else
                    {
                        push(s1, gettop(s2));
                        pop(s2);
                        push(s2,c[i]);
                    }
                }

}

void putstack1(sqstack &s)
{
    while(s.top > s.base)
    {
        printf("%c", *(s.top-1));
        s.top--;
    }

}
void putstack2(sqstack &s)
{
    while(s.top > s.base)
    {
        printf("%c", *(s.base));
        s.base++;
    }

}
char midtranlate(char c[])
{
    int n=strlen(c), i;
    for(i=0;i<n;i++)
    {
        if(c[i]!='('&&c[i]!=')'&&c[i]!='#')
        printf("%c", c[i]);
    }
}
int main()
{
    char c[110];
    sqstack s;
    sqstack s1, s2;
    initstack(s);
    initstack(s1);
    initstack(s2);
    scanf("%s", c);

    pretranslate(s1, s2, c);
    putstack2(s2);
    putstack1(s1);
    printf("\n");
    midtranlate(c);
    printf("\n");
    lasttranslate(s, c);
    putstack1(s);//栈可能不为空

return 0;
}