02-线性结构3. 求前缀表达式的值（25）

算术表达式有前缀表示法、中缀表示法和后缀表示法等形式。前缀表达式指二元运算符位于两个运算数之前，例如2+3*(7-4)+8/4的前缀表达式是：+ + 2 * 3 - 7 4 / 8 4。请设计程序计算前缀表达式的结果值。

输入格式说明：

输入在一行内给出不超过30个字符的前缀表达式，只包含+、-、*、\以及运算数，不同对象（运算数、运算符号）之间以空格分隔。

输出格式说明：

输出前缀表达式的运算结果，精确到小数点后1位，或错误信息“ERROR”。

样例输入与输出：

序号	输入	输出
1	+ + 2 * 3 - 7 4 / 8 4	13.0
2	/ -25 + * - 2 3 4 / 8 4	12.5
3	/ 5 + * - 2 3 4 / 8 2	ERROR
4	+10.23	10.2

求前缀表达式的算法不难，这题合适的数据结构显然是栈。这题稍复杂的地方就是对输入的处理以及栈的基本操作。

首先，输入的每一项数据存储在栈的每一个节点中这是确定的。但是所输入的数据的类型却不一致。栈的节点struct Node里设计了四个成员变量。
struct Node{
char opr;
float num;
int type; //用来标记该节点是个操作符还是操作数
struct Node* Next;
};

我们最终要把所输入的操作符以char形式存储，所输入的操作数以float形式存储。

这里，先统一以字符串形式通过scanf("%s")输入，用空格隔开。然后再判断该字符串是表示操作数还是操作符，并通过设计两个相应函数把字符串转化为字符形式的操作符 以及 把字符串转化为float操作数。

每输入一项数据后，都要对栈进行相应操作。
如果输入的是操作符则push。
如果当前输入的是操作数则分两种情况。
0. 此时是空栈，直接push进栈。
1. 此时栈顶是操作符，则直接push进栈。
2. 此时栈顶也是操作数，即连续出现了两个操作数，那么弹出栈顶的操作数（而后栈顶指针已变），再弹出栈顶的操作符。通过这个操作数、操作符以及当前输入的操作数计算得出一个新的操作数。此时再把这个新的操作数压入栈中，进栈操作同样递归地进行栈顶是符号还是数字的判断，直至可直接push进栈。
最后栈顶操作数即为前缀表达式的结果。

除此之外，需注意的细节有：
1. 注意ERROR情况的出现，进行除法操作前判断作为除数的操作数是否为零。
2. 成员变量Next未显式赋值的时候并没有默认为NULL

源代码

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

typedef struct Node* Stack;
typedef struct Node* Position;

struct Node{
	char opr;
	float num;
	int type;  //0表示操作符 1表示数字
	struct Node* Next;
};

void Push(char c, Stack S)
{
	Position P;
	Position Temp;
	Temp = (Position)malloc(sizeof(struct Node));
	Temp->opr = c;
	Temp->type = 0;
	Temp->Next = NULL;
	Temp->Next = S->Next;
	S->Next = Temp;
}



int IsEmpty(Stack S)
{
	return S->Next == NULL;
}

float PopNum(Stack S)
{
	Position Temp;
	float num;

	Temp = S->Next;
	num = Temp->num;
	S->Next = Temp->Next;
	free(Temp);
	return num;
}

char PopOpr(Stack S)
{
	Position Temp;
	char opr;

	Temp = S->Next;
	opr = Temp->opr;
	if (Temp->Next != NULL)
		S->Next = Temp->Next;
	else
		S->Next = NULL;
	free(Temp);
	return opr;
}

void Push(float n, Stack S)
{
	Position P;
	Position Temp;
	Temp = (Position)malloc(sizeof(struct Node));
	Temp->num = n;
	Temp->type = 1;
	Temp->Next = NULL;
	if (S->Next == NULL)  //如果此前一个是操作符或栈空，那么直接压入
	{
		Temp->Next = S->Next;
		S->Next = Temp;
	}
	else if (S->Next->type == 0)
	{
		Temp->Next = S->Next;
		S->Next = Temp;
	}
	else{  //如果此前一个是数字
		//char c = S->Next->Next->opr;
		float m = PopNum(S);
		char c = PopOpr(S);

		if (c == '+')
			Push(n + m, S);
		else if (c == '-')
			Push(m - n, S);
		else if (c == '*')
			Push(m * n, S);
		else{
			if (n == 0)
			{
				printf("ERROR");
				exit(0);
			}
			else
				Push(m / n, S);
		}

	}
}

int IsOpr(char in[])
{
	int length = strlen(in);
	if (length==1 && (in[0] == '+' || in[0] == '-' || in[0] == '*' || in[0] == '/'))
		return 1;
	else
		return 0;
}

float StrToNum(char s[])
{
	int length = strlen(s);
	float result = 0;
	int flag = 1;
	int right = 0;
	int j = 0;
	for (int i = 0; i < length; i++)
	{
		if (s[i] == '.'){
			right = 1;
			continue;
		}

		if (i == 0 && s[i] == '+')
			flag = 1;
		else if (i == 0 && s[i] == '-')
			flag = -1;
		else if (!right) {
			result = 10 * result + s[i] - '0';
		}
		else{
			j++;
			result = result + (s[i] - '0') / (pow(10.0, j));
		}
	}
	return result*flag;
}

void PrintStack(Stack S)
{
	Position P;
	P = S->Next;
	while (P != NULL)
	{
		if (P->type == 0)
		{
			printf("%c", P->opr);
		}
		else
			printf("%f", P->num);

		P = P->Next;
	}
	printf("\n");
}

int main()
{
	char in[30];
	char buff;
	float result = 0;
	Stack S;
	S = (Stack)malloc(sizeof(struct Node));
	S->Next = NULL;
	scanf("%s", in);
	buff = getchar();
	if (!IsOpr(in))	//如果输入的第一项就是数字，那这个数字就是结果
	{
		float r = StrToNum(in);
		printf("%.1f", r);
		return 0;
	}

	//如果输入的第一项是操作符
	Push(in[0], S);
	while (buff != '\n')
	{
		scanf("%s", in);
		if (IsOpr(in))  //如果输入的是操作符，就直接入栈
		{
			Push(in[0], S);  
		}
		else  //如果输入的数字
		{
			Push(StrToNum(in), S);
		}
		buff = getchar();
	}
	
	//PrintStack(S);

	result = S->Next->num;
	printf("%.1f", result);
	return 0;
	
}