中缀表达式变换为后缀表达式（逆波兰表达式）

实现原理参考：https://blog.csdn.net/beiyetengqing/article/details/8066568
C语言实现如下：
中缀表达式转换为逆波兰表达式（后缀表达式）

/* 中缀表达式转换为逆波兰表达式（后缀表达式） */
#define STACK_SIZE 10
typedef struct STACK{
	char *base;
	char *top;
	int stack_size;
}rpn_stack;
rpn_stack *init_stack() {
	rpn_stack *my_stack = (rpn_stack *)calloc(1,sizeof(rpn_stack));
	my_stack->base = (char *)calloc(1, sizeof(char) * STACK_SIZE);
	my_stack->top = my_stack->base;
	my_stack->stack_size = 0;
	return my_stack;
}

static int get_stack_len(rpn_stack *my_stack) {
	return my_stack->top - my_stack->base;
}

static void push(rpn_stack *my_stack, char c) {
	int len = get_stack_len(my_stack);
	if ( len >= STACK_SIZE ) {
		my_stack->base = (char *)realloc(my_stack->base, sizeof(char) * (len + STACK_SIZE ));
	}
	*my_stack->top = c;
	my_stack->top++;
	my_stack->stack_size++;
}

static char pop(rpn_stack *my_stack) {
	if (my_stack->base == my_stack->top) {
		return '\0';
	}
	char c = *(--my_stack->top);
	my_stack->stack_size--;
	return c;
}

static char top(rpn_stack *my_stack) {
	if (my_stack->base == my_stack->top) {
		return '\0';
	}
	char *p = my_stack->top;
	char c = *(--p);
	return c;
}

static void free_stack(rpn_stack *my_stack) {
	free(my_stack->base);
	free(my_stack);
}

static void print_stack(rpn_stack *my_stack) {
	char *p = my_stack->base;
	while (p != my_stack->top)
	{
		printf("%c", *p++);
	}
	printf("\n");
}

static int get_precedence(char p) {
	switch (p) {
	    case '(' :
	    case ')' :
		    return 0;
		case '+' :
		case '-' :
			return 1;
		case '*' :
		case '/' :
			return 2;
		default :
			return -1;
	}
}

int main() {
	rpn_stack *my_stack = init_stack();
	//char str[] = "5 + ((1 + 2) * 4) - 3";  // 5 1 2 + 4 * + 3 −
	char str[] = "3 + 4 * ( 5 - 2 ) / 2"; // 3 4 5 2 - × 2 / +
	char out[100];

	char *p = str;
	int i = 0;
	while (*p != '\0')
	{
		//printf("\np is [%c]\n", *p);
		//print_stack(my_stack);
		if (*p == ' ') {
			p++;
			continue;
		}
		if (*p >= '0' && *p <= '9'){
			out[i++] = *p++;
			continue;
		}

		if (*p == '(') {
			push(my_stack, *p);
			p++;
			continue;
		}

		if (*p == ')') {
			char tmp;
			while ((tmp = pop(my_stack)) != '(')
			{
				out[i++] = tmp;
			}
			p++;
			continue;
		}

		char c = top(my_stack);
		int c_pre = get_precedence(c);

		char op = *p;
		int op_pre = get_precedence(op);

		if (op_pre > c_pre) {
			push(my_stack, op);
		}
		else {
			out[i++] = pop(my_stack);
			push(my_stack, op);
		}
		p++;
	}
	while (get_stack_len(my_stack) > 0){
		out[i++] = pop(my_stack);
	}
	out[i] = '\0';
	printf("[%s]\n", out);
	
	return 0;
}

逆波兰表达式求值

/* 逆波兰表达式（后缀表达式）求值*/

typedef struct rpn_stack {
	int base;
	int top;
	int stack_size;
	int *data;
}rpn_stack;

rpn_stack * init_stack() {
	rpn_stack *my_stack = (rpn_stack *)calloc(1, sizeof(rpn_stack));
	my_stack->base = 0;
	my_stack->top = 0;
	my_stack->stack_size = 0;
	my_stack->data = (int *)calloc(1, sizeof(int) * STACK_SIZE);
	return my_stack;
}

void push(rpn_stack *my_stack, int num) {
	int len = my_stack->stack_size;
	if (len >= STACK_SIZE - 1) {
		my_stack->data = (int *)realloc(my_stack->data, sizeof(int) * (STACK_SIZE + len));
	}
	my_stack->data[my_stack->top++] = num;
	my_stack->stack_size++;
}

int pop(rpn_stack *my_stack) {
	my_stack->stack_size--;
	return my_stack->data[--my_stack->top];
}

void print_stack(rpn_stack *my_stack) {
	int i = my_stack->stack_size;
	while (i > 0) {
		printf("%d ", my_stack->data[i - 1]);
		i--;
	}
	printf("\n");
}

int get_rpn_value(char *str) {
	rpn_stack *val_stack = init_stack();

	int len = strlen(str);
	while (len--)
	{
		printf("str is [%c]\n", *str);
		if (*str >= '0' && *str <= '9') {
			push(val_stack, *str - '0');
		}
		else if (*str == ' ') {
			str++;
			continue;
		}
		else {
			int n1 = pop(val_stack);
			int n2 = pop(val_stack);
			int val = 0;
			switch (*str) {
			    case '+' :
					val = n1 + n2;
					break;
				case '-' :
					val = n2 - n1;
					break;
				case '*' :
					val = n1 * n2;
					break;
				case '/' :
					if (n1 == 0)
						return INT_MIN;
					val = n2 / n1;
					break;
				default:
					break;		
			}
			push(val_stack, val);
		}
		str++;
		print_stack(val_stack);
		if (len == 0)
		{
			return pop(val_stack);
		}
	}
}

int main() {
	char str[] = "3 4 5 2 - * 2 / +"; // 3 + 4 * ( 5 - 2 ) / 2
	int val = get_rpn_value(str);
	printf("val is %d\n", val);
	stop;
}