简单的逆波兰式 c语言

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define OK 1
#define ERROR 0
const int maxn = 20;

typedef struct Stack{
	int max_size, top_index;
	char *elements;
}Stack;

void init(Stack *s, int size){
	s->max_size = size;
	s->top_index = -1;
	s->elements = (char*)malloc(sizeof(char)*size);
}

int push(Stack *s, char value){
	if (s->top_index >= s->max_size - 1){
		return ERROR;
	}
	s->top_index++;
	s->elements[s->top_index]=value;
	return OK;
}

void pop(Stack *s){
	if (s->top_index <0){
		return;
	}
	s->top_index--;
}

int top(Stack *s){
	return s->elements[s->top_index];
}

void clear(Stack *s){
	free(s->elements);
	free(s);
}

int isOperator(char c){
	return (c == '+' || c == '-' || c == '*' || c == '/');
}

int priority(char c){
	if (c == '*' || c == '/'){
		return 2;
	}
	if (c == '+' || c == '-'){
		return 1;
	}
	else{
		return 0;
	}
}

int op(int a, int b, char c){
	int res;
	if (c == '+'){
		res = a + b;
	}
	else if (c == '-'){
		res = a - b;
	}
	else if (c == '*'){
		res = a*b;
	}
	else if (c == '/'){
		res = a / b;
	}
	return res;
}

int main(){
	char s[maxn];
	scanf("%s", &s);
	int n = strlen(s);
	Stack *stack = (Stack*)malloc(sizeof(Stack));
	init(stack, n);
	char change[maxn];
	int outlen = 0;
	memset(change, '\0', maxn);
	memset(stack->elements, '\0', n);
	for (int i = 0; i<n; i++){
		if (s[i] >= '0'&&s[i] <= '9'){
			change[outlen++] = s[i];
		}
		while (isOperator(s[i])){
			if (stack->top_index == -1 || priority(s[i])>priority(top(stack))){
				push(stack,s[i]);
				break;
			}
			else{
				change[outlen++] = top(stack);
				pop(stack);
			}
		}
	}
	while (stack->top_index != -1){
		change[outlen++] = top(stack);
		pop(stack);
	}
	for (int i = 0; i < sizeof(change); i++){
		if (change[i] >= '0'&&change[i] <= '9'){
			push(stack, change[i]);
		}
		else if (isOperator(change[i])){
			char c = change[i];
			int b = top(stack)-'0';
			pop(stack);
			int a = top(stack)-'0';
			pop(stack);
			push(stack, op(a, b, c)+'0');
		}
	}
	printf("%d", top(stack)-'0');
	clear(stack);
	return 0;
}

参考博客http://blog.csdn.net/linraise/article/details/20459751
对于将一个式子转换为逆波兰式。
首先要明确的是，输入为一个字符串，需要一个栈作为辅助空间，输出为一个字符串。

1.首先，从左向右扫描字符串，对于每一个字符
2.若为数字
直接输出到输出字符串
3.while(当扫描到的为操作符时){
首先确定栈是否为空或栈顶操作符优先级比操作符低
就将操作符压栈，退出循环
或者
出栈至输出字符串
}
4.返回第一步
5.循环输出栈至输出字符串
结束

对于后缀表达式求值
将字符串不断压栈 。当遇到操作符时，弹出两次栈顶，并计算结果，将结果入栈。并继续计算。

注意事项，当计算结果时注意操作数顺序，防止操作数颠倒。