[数据结构与算法]根据输入的逆波兰表达式进行计算（栈）

最近在学习数据结构与算法，老师留了关于逆波兰式的计算，其中有关于负数的处理。我的解决方法如下：

1.负数与减法的差异在于单目与双目，所以如果是负数，那么‘-’后应该是数字我们可以跳过‘-’继续读取后面的数字，然后再进行处理。至于减法就很简单了。

下面是实现代码。

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>

#define MAX_LEN 20

typedef struct
{
	int data[MAX_LEN];
    int top;
}Stack;

void InitStack(Stack *s); 

int Push(Stack *p,int x);

int Pop(Stack *L,int *x);

int main()
{
	Stack s;
	int a,b,d;
    char str[20];//缓冲区
	void InitStack(Stack *s);	
    int i = 0;
	char c;
	printf("输入逆波兰表达式，数据之间以','隔开，以'#'结尾\n"); 
	scanf("%c",&c);
	while(c != '#')
	{
        while(isdigit(c))//用于过滤数字，将数字存储到str里再Push 
        {
            str[i] = c;
            i++;
            str[i] = '\0';
            scanf("%c",&c);
            if(c == ',')
            {
                d = atoi(str);
                Push(&s,d);
                i = 0;
                break;
            }
        }
        
        while(c == '-')//负数与减法的区别 
        {
        	scanf("%c",&c);
        	if(isdigit(c))//负数 ,即单目运算，可跳过负号继续读取数字直至','，再进行处理 
        	{
        		while(isdigit(c))
        		{
        			str[i] = c;
            		i++;
            		str[i] = '\0';
            		scanf("%c",&c);
            		if(c == ',')
            		{
                		d = -atoi(str);
                		Push(&s,d);
                		i = 0;
                		break;
            		} 
				}
			}
			else//减法 
			{
				Pop(&s,&a);
				Pop(&s,&b);
				Push(&s,b-a);
				break;
			}
		}
		switch(c)
		{
			case '+':
				Pop(&s,&a);
				Pop(&s,&b);
				Push(&s,b+a);
				break;
			/*case '-':
				Pop(&s,&a);
				Pop(&s,&b);
				Push(&s,b-a);
				break;*/
			case '*':
				Pop(&s,&a);
				Pop(&s,&b);
				Push(&s,a*b);
				break;
			case '/':
				Pop(&s,&a);
				Pop(&s,&b);
				if(a!=0)
				{
					Push(&s,b/a);
				}
				else
				{
					printf("除数为0\n");
					return -1;
				}
				break;
				
		}
		scanf("%c",&c);
	}
	Pop(&s,&b);
    printf("结果为%d",b);
    return 0;
}

void InitStack(Stack *s)
/*初始化*/ 
{
	
    s = (Stack *)malloc(sizeof(*s));
    s->top = -1;
}

int Push(Stack *s,int x)
//压栈 
{
    if (s->top == MAX_LEN - 1)
    {
    return -1;
    }
    s->top++;
    s->data[s->top] = x;
    return 0;
}

int Pop(Stack *s,int *x)
//弹栈 
{
    if (s->top == -1)
    {
    return -1;
    }
    *x = s->data[s->top];
    s->top--;
    return 0;
}