中缀转后缀表达式

算法思路

扫描中缀表达式exp， 遇到一个运算符op时，有以下几种情况：

1. 如果栈空，直接入栈；

2. 当op的优先级大于栈顶运算符时，直接进栈；

3. ··················小于··················，依次出栈运算符并存入后缀表达式postexp，直到栈顶运算符优先级小于op，再将op入栈；

4. 当op为 '(' 时，表示一个子表达式开始，直接入栈；

5. 当op为 ')' 时， 子表达式结束，依次出栈运算符并存入postexp，直到栈顶为'('，再将'(' 出栈；

6. 如果栈顶是'('，op是算术运算符，则直接进栈）

注意：

如果*遇到栈顶也为*，需要将*出栈（也就是说栈顶为同优先级的也要出栈），否则会出错

比如表达式为5*6/5*4，正确的后缀表达式是56*5/4*

如果不出栈同优先级运算符，将会得到5654*/*，这样计算后缀将是错的。

此外，在后缀表达式中的每个数字串末尾添加‘#’，以标识

#include <malloc.h>
#include <iostream>

#define MaxSize 100  
using namespace std;
 
typedef struct {
	char data[MaxSize];
	int top;
}SqStack;

void InitStack(SqStack *&s) {
	s = (SqStack *)malloc(sizeof(SqStack));
	s->top = -1;
}

bool Push(SqStack *&s, char e) {
	if (s->top == MaxSize - 1) return 0;
	s->top++;
	s->data[(s->top)] = e;
	return 1;
}

bool Pop(SqStack *&s, char &e) {
	if (s->top == -1) return 0;
	e = s->data[s->top];
	s->top--;
	return 1;
}

bool GetTop(SqStack *s, char &e) {
	if (s->top == -1) return 0;
	e = s->data[s->top];
	return 1;
}

bool StackEmpty(SqStack *s) {
	return (s->top == -1);
}

void DestroyStack(SqStack *&s) {
	free(s); s = NULL;
}
void trans(char *exp, char postexp[]) {//tranfer the infix exp to postexp
	char e;
	int i = 0;//as postexp's index
	SqStack *Optr;//define operator stack pointer
	InitStack(Optr);
	while (*exp != '\0') {
		switch (*exp) {

		case '(':
			Push(Optr, '(');
			exp++;//continue to scan
			break;
		case ')':
			Pop(Optr, e);
			while (e != '(') {
				postexp[i++] = e;
				Pop(Optr, e);
			}
			exp++;
			break;
		case '+':
		case '-':
			while (!StackEmpty(Optr)) {
				GetTop(Optr, e);
				if (e != '(') {
					postexp[i++] = e;
					Pop(Optr, e);
				}
				else break;
			}
			Push(Optr, *exp);
			exp++;
			break;
		case '*':
		case '/':
			while (!StackEmpty(Optr)) {
				GetTop(Optr, e);
				if (e == '*' || e == '/') {
					postexp[i++] = e;
					Pop(Optr, e);
				}
				else break;
			}
			Push(Optr, *exp);
			exp++;
			break;
		default:
			while (*exp >= '0' && *exp <= '9') {
				postexp[i++] = *exp;
				exp++;
			}
			postexp[i++] = '#';//identify numeric
		}
	}
	while (!StackEmpty(Optr)) {
		Pop(Optr, e);
		postexp[i++] = e;
	}
	postexp[i] = '\0';
	DestroyStack(Optr);
}
int main() {
	
	char exp[] = "(56-20)/(4+2)";
	char postexp[MaxSize];
	trans(exp, postexp);
	cout << postexp;

	return 0;
}