简单计算器

题目描述

Roliygu曾经沉迷于SICP大半个学期，在沉迷期间，他对LISP语言的算术表达式很感兴趣，于是类比写出了一种后缀表达式。后缀表达式是指的将两个操作数之间的操作符移到两个操作数之后的表达式。比如原来的表达式为（1-2）*（4+5）=-9，写成后缀表达式就成了 1 2 - 4 5 + * 

输入

第一行输入n，0<n<10，表示有n行表达式

接下来的n行，每行一个后缀表达式，保证表达式合法，且不使用除四则运算之外的操作。不会输入负数

输出

输出n行，每行为输入表达式的最终结果，结果保留两位小数，不需要高精度数。

样例输入

1
1 2 - 4 5 + *

样例输出

-9.00

（1）利用栈来实现，对于后缀表达式，这种方式太过去麻烦

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

#define INIT_SIZE 10
#define INCREAS_SIZE 2
#define ElemType float
typedef struct
{
	ElemType *base;
	ElemType *top;
	int capacity;
}Sqstack;

void Init(Sqstack *S)
{
	S->base = (ElemType*)malloc(sizeof(ElemType)*INIT_SIZE);
	if (!S->base)
		exit(-1);
	S->top = S->base;
	S->capacity = INIT_SIZE;
}

void Push(Sqstack *S, ElemType e)
{
	if (S->top - S->base >= S->capacity) 
	{
		S->base = (ElemType *)realloc(S->base, sizeof(ElemType)*(INIT_SIZE + INCREAS_SIZE));
		if (!S->base)
			exit(-1);
		S->top = S->top + INCREAS_SIZE;
		S->capacity += INCREAS_SIZE;
	}
	*S->top= e;
	S->top++;
}

void ClearStack(Sqstack *S)
{
	S->top = S->base;
} 

void DestroyStack(Sqstack *S)
{
	free(S->base);
	S->base = NULL;
	S->top = NULL;
	S->capacity = 0;
}

int  Pop(Sqstack *S, ElemType *e)
{
	if (S->base == S->top)
		return 0;
	S->top--;
	*e =*S->top ;
	return 0;
}

int IsEmpty(Sqstack *S)
{
	return (S->top == S->base) ? 1 : 0;
}

int main()
{
	Sqstack s1;
	char s;
	float a = 0;
	float b = 0;
	float e = 0;
	int count =0;
	Init(&s1);
	int n;
	scanf("%d\n",&n);

	while(count !=n)
	{
		while ( (s=getchar()) != '\n')
		{
			if ( s!='+' && s!='-' && s!='*' && s!='/'&& s!=' ') 
			{
				switch(s)
				{
					case '0':e=0;break;
					case '1':e=1;break;
					case '2':e=2;break;
					case '3':e=3;break;
					case '4':e=4;break;
					case '5':e=5;break;
					case '6':e=6;break;
					case '7':e=7;break;
					case '8':e=8;break;
					case '9':e=9;break;
					default:
						break;
				}
				Push(&s1,e);
			}
			else if(s!=' ')
			{
				Pop(&s1, &a);
				Pop(&s1, &b);
				switch (s)
				{
				case '+':
						Push(&s1, b + a);
						break;
				case '-':
						  Push(&s1, b - a);
						  break;
				case '*': 
						 Push(&s1, a*b);
						 break;
				case '/': 
						 Push(&s1, b / a);
						 break;
				default:
					break;
				}		
			}
			else
				;
		}
		if (!IsEmpty(&s1))
		{
			Pop(&s1, &e);
			printf("%0.2f",e);
		}
		ClearStack(&s1);
		++count;
		if(count == n)
			break;
	}
	DestroyStack(&s1);
	return 0;
}

（2）对于上面复杂的栈实现，利用数组实现是很简单的

#include <stdio.h>

int main()
{

	char s;
	float a = 0;
	float b = 0;
	float e = 0;
	int count =0;
	float f[5] = {};
	int n;
	int i = -1;
	scanf("%d\n",&n);

	while(count !=n)
	{
		while ( (s=getchar()) != '\n')
		{
			if ( s!='+' && s!='-' && s!='*' && s!='/'&& s!=' ') 
			{
				switch(s)
				{
					case '0':e=0;break;
					case '1':e=1;break;
					case '2':e=2;break;
					case '3':e=3;break;
					case '4':e=4;break;
					case '5':e=5;break;
					case '6':e=6;break;
					case '7':e=7;break;
					case '8':e=8;break;
					case '9':e=9;break;
					default:
						break;
				}
				f[++i] = e;
			}
			else if(s!=' ')
			{
				a = f[i-1];
				b = f[i];
				switch (s)
				{
				case '+':
						f[--i] = a + b;
						break;
				case '-':
						f[--i] = a - b;
						break;
				case '*': 
						 f[--i] = b * a;
						 break;
				case '/': 
						 f[--i] = a/b;
						 break;
				default:
					break;
				}		
			}
			else
				;
		}
		
		printf("%0.2f\n",f[i]);
		i = -1;
		++count;
		if(count == n)
			break;
	}
	return 0;
}