数据结构课实验习题--中缀表达式转换为后缀表达式并求值

所谓中缀表达式与后缀表达式的定义,即是看运算符在操作数的位置如何

中缀表达式即作符是以中缀形式处于操作数的中间(例:3 + 4)

后缀表达式(也叫逆波兰表达式)则为3 4 +

以下摘抄百度百科:

一个表达式E的后缀形式可以如下定义:

(1)如果E是一个变量或常量,则E的后缀式是E本身。

(2)如果E是E1 op E2形式的表达式,这里op是任何二元操作符,则E的后缀式为E1'E2' op,这里E1'和E2'分别为E1和E2的后缀式。

(3)如果E是(E1)形式的表达式,则E1的后缀式就是E的后缀式。

如:我们平时写a+b,这是中缀表达式,写成后缀表达式就是:ab+

(a+b)*c-(a+b)/e的后缀表达式为:

(a+b)*c-(a+b)/e

→((a+b)*c)((a+b)/e)-

→((a+b)c*)((a+b)e/)-

→(ab+c*)(ab+e/)-

→ab+c*ab+e/-

由这个例子可以看出,中缀表达式转化为后缀表达式的实质就是,将每个 “部分式” 的算术符号移到式子后面

还是以百度的例子为例:

第一步,把整个式子看作一个部分,左边的数是(a+b)*c,右边的是(a+b)/e,将➖号移到式子最后

第二步,再把第一步式子的两个“数”做相似处理,例如(a+b)*c,看成(a+b) 和c,将✖号移到式子最后

第三步。。。。。。

那么我们如何使用栈来实现转换呢?

读入中缀表达式infix[i];

1.遇到数字 0-9 ,则将其直接送进后缀表达式postfix[]数组

2.如果遇到左括号 '(' ,入栈(起到了限制范围的作用)

3.如果遇到右括号')' ,弹出上一个左括号'('之前的所有运算符并送入postfix ;注意左括号'('只弹出不赋值

4.如果遇到运算符(+ - * /),就将栈中所有优先级大于等于它的运算符出栈,直到栈空,再把该运算符入栈

后缀表达式求值:

1.遇到数字0-9,直接进栈

2.遇到运算符(+ - * /),将栈中头两个数弹出来进行运算,并将结果入栈

附代码:

#include 
#include 
#include 

typedef struct _nodechar
{
    char data;
    struct _nodechar *next;
} nodechar;

typedef struct _stackchar
{
    int size;
    nodechar *top;
} stackchar;
typedef struct _nodeint
{
    int data;
    struct _nodeint *next;
} nodeint;

typedef struct _stackint
{
    int size;
    nodeint *top;
} stackint;

int getPriority(char opt)
{
    if(opt == '+' || opt =='-')
        return 1;
    if(opt == '*' || opt == '/')
        return 2;
    return 0;
}

int calucalte(int opt1, char opt, int opt2)
{
    switch(opt)
    {
    case '+':
        return opt1 + opt2;
        break;
    case '-':
        return opt1 - opt2;
        break;
    case '*':
        return opt1 * opt2;
        break;
    case '/':
        return opt1 / opt2;
        break;
    }
    return 0;
}
stackchar *createStackchar(void)
{
    stackchar* p = (stackchar*)malloc(sizeof(stackchar));
    p->size = 0;
    p->top = NULL;
    return p;
}
void pushchar(stackchar* pStack, char x)
{
    nodechar *t = (nodechar*)malloc(sizeof(nodechar));
    t->data = x;
    t->next = pStack->top;
    pStack->top = t;
    pStack->size++;
}
void popchar(stackchar* pStack)
{
    nodechar *t = pStack->top;
    pStack->top = t->next;
    free(t);
    pStack->size--;
}
char topchar(stackchar* pStack)
{
    return pStack->top->data;
}
bool emptychar(stackchar* pStack)
{
    return pStack->top == NULL;
}
void destroyStackchar(stackchar* pStack)
{
    while (!emptychar(pStack))
    {
        popchar(pStack);
    }
    free(pStack);
}

stackint *createStackint(void)
{
    stackint* p = (stackint*)malloc(sizeof(stackint));
    p->size = 0;
    p->top = NULL;
    return p;
}
void pushint(stackint* pStack, int x)
{
    nodeint *t = (nodeint*)malloc(sizeof(nodeint));
    t->data = x;
    t->next = pStack->top;
    pStack->top = t;
    pStack->size++;
}
void popint(stackint* pStack)
{
    nodeint *t = pStack->top;
    pStack->top = t->next;
    free(t);
    pStack->size--;
}
int topint(stackint* pStack)
{
    return pStack->top->data;
}
bool emptyint(stackint* pStack)
{
    return pStack->top == NULL;
}
void destroyStackint(stackint* pStack)
{
    while (!emptyint(pStack))
    {
        popint(pStack);
    }
    free(pStack);
}
int main(void)
{
	//转换部分 
    int n;
    scanf("%d", &n);
    while(n--)
    {
        char infix[21], postfix[21] = "\0";
        int index = 0;
        scanf("%s", infix);
        stackchar *pStackchar = createStackchar();
        for(int i = 0; infix[i] != '\0'; i++)
        {
            if(infix[i] >= '0' && infix[i] <= '9')
            {
                postfix[index++] = infix[i];
            }
            else if(infix[i] == '(')
            {
                pushchar(pStackchar, infix[i]);
            }
            else if(infix[i] == ')')
            {
                char c = topchar(pStackchar);
                popchar(pStackchar);
                while(c != '(')
                {
                    postfix[index++] = c;
                    c = topchar(pStackchar);
                    popchar(pStackchar);
                }
            }
            else//算术符号 
            {
                if(emptychar(pStackchar) || getPriority(infix[i]) > getPriority(topchar(pStackchar)))
                {
                    pushchar(pStackchar, infix[i]);
                }
                else
                {
                    while(!emptychar(pStackchar) && getPriority(infix[i]) <= getPriority(topchar(pStackchar)))
                    {
                        char c = topchar(pStackchar);
                        popchar(pStackchar);
                        postfix[index++] = c;
                    }
                    pushchar(pStackchar, infix[i]);
                }
            }
        }
        while(!emptychar(pStackchar))
        {
            char c = topchar(pStackchar);
            popchar(pStackchar);
            postfix[index++] = c;
        }
        printf("%s", postfix);
        destroyStackchar(pStackchar);
        
        //算值部分,优先级高的数在栈顶,优先级高的计算符号在符号序列最左边 
        stackint *pStackint = createStackint();
        for(int i = 0; postfix[i] != '\0'; i++)
        {
            if(postfix[i] >= '0' && postfix[i] <= '9')
            {
                int m = postfix[i] - '0';
                pushint(pStackint, m);
            }
            else
            {
                char opt = postfix[i];
                int opt2, opt1;
                opt2 = topint(pStackint);
                popint(pStackint);
                opt1 = topint(pStackint);
                popint(pStackint);
                pushint(pStackint, calucalte(opt1, opt, opt2));//先弹出的数要放在操作符的右边
            }
        }
        int ans = topint(pStackint);
        printf(" %d\n", ans);
        popint(pStackint);
        destroyStackint(pStackint);
    }
    return 0;
}

你可能感兴趣的:(栈,数据结构)