栈-逆波兰表达法【东北大学oj数据结构3-1】C语言

逆波兰表示法是一种表示法，其中每个运算符都在其所有操作数的后面出现。例如，表达式(1+2)×(5+4)可以表示为逆波兰表达式1 2 + 5 4 + ×。逆波兰表示法的优点之一是它没有括号。
编写一个程序，读取逆波兰表示法中的表达式并打印计算结果。
逆波兰表示法中的表达式是使用栈计算的。要计算表达式，程序应按顺序读取符号。如果符号是操作数，则应将相应的值压入栈。另一方面，如果符号是一个运算符，程序应该从堆栈中弹出两个元素，执行相应的操作，然后将结果压入栈。程序应重复此操作。

输入

在一行中给出一个表达式。两个连续符号（操作数或运算符）由空格字符分隔。您可以假设只有 +, - 和 * 作为运算符给出，并且表达式中的数字都是小于106的正整数。

输出

在一行中打印计算结果。

约束

2≤ 表达式中数字的数量 ≤ 100
1≤ 表达式中操作符的数量≤ 99
−10^9 ≤ 堆栈中的值 ≤ 10^9

输入样例

1 2 + 3 4 - *

 输出样例

-3

C语言需要自己写栈 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Node
{
    int value;
    struct Node* next;
};
struct Stack
{
    struct Node* top;
};
struct Stack* create()
{
    struct Stack* s=(struct Stack*)malloc(sizeof(struct Stack));
    s->top=NULL;
    return s;
}
int isEmpty(struct Stack* s)
{
    return s->top==NULL;
}
void push(int x,struct Stack* s)
{
    struct Node* tmpcell=(struct Node*)malloc(sizeof(struct Node));
    tmpcell->value=x;
    tmpcell->next=s->top;
    s->top=tmpcell;
}
int pop(struct Stack* s)
{
    if(isEmpty(s))
        return -1;
    struct Node* temp=s->top;
    int x=temp->value;
    s->top=temp->next;
    free(temp);
    return x;
}
int main()
{
    struct Stack* ms=create();
    char c[400];
    char a[200][20];
 
    int j=0;
    fgets(c,sizeof(c),stdin);
    char* token=strtok(c," \n");
    while(token!=NULL)
    {
        strcpy(a[j++],token);
        token=strtok(NULL," ");
    }
    for(int i=0;i<j;i++)
    {
        if(a[i][0]>='0'&&a[i][0]<='9')
        {
            int num=atoi(a[i]);
            push(num,ms);
        }
        else
        {
            int y=pop(ms);
            int x=pop(ms);
            if(a[i][0]=='+')
            {
                int z=x+y;
                push(z,ms);
            }
            if(a[i][0]=='-')
            {
                int z=x-y;
                push(z,ms);
            }
            if(a[i][0]=='*')
            {
                int z=x*y;
                push(z,ms);
            }
        }
    }
    int t=pop(ms);
    printf("%d",t);
    return 0;
}