栈结构之后缀表达式

/*
栈采用顺序栈存储，试设计算法实现将表达式转换成后缀表达式输出。
例如，输入表达式：	a+b/c-(d*e+f)*g
输出其后缀表达式：	abc/+de*f+g*-
*/

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

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

typedef int Status;
typedef char SElemType;

typedef struct 
{
	char *base;
	char *top;
	int stacksize;
}SqStack;

Status InitStack(SqStack &S);
Status Push(SqStack &S, SElemType &e);
Status Pop(SqStack &S, SElemType &e);
Status GetTop(SqStack S, SElemType &e);
Status Matching(SqStack &S, char expression[]);
int StackLength(SqStack S);

int main(){
	SqStack S;
	InitStack(S);

	printf("以下是表达式的转换");
	char expression[] = "a+b/c-(d*e+f)*g";
	printf("%s
", expression);
	Matching(S, expression);

	return 0;
}

Status InitStack(SqStack &S){
	S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
	if (!S.base)
	{
		exit(OVERFLOW);
	}
	S.top = S.base;
	S.stacksize = STACK_INIT_SIZE;
	return OK;
}

int  StackLength(SqStack S){
	// 返回栈中存储数据的部分的长度
	return S.top - S.base;
}

Status GetTop(SqStack S, SElemType &e){
	//空栈
	if (S.top == S.base){
		return ERROR;
	}
	//不可以用S.top - 1，因为这里只是读取，并非删除
	e = *(S.top - 1);

	return OK;
}

Status Push(SqStack &S, SElemType &e){
	//栈满
	if (S.top - S.base >= S.stacksize){
		S.base = (SElemType *)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));
		if (!S.base){
			exit(OVERFLOW);
		}
		//指针的加减量实际上就是在地址上以对应的类型空间的移动
		S.top = S.base + S.stacksize;
		S.stacksize += STACKINCREMENT;
	}
	//e作为栈顶元素，先赋值，再向上移动
	*S.top++ = e;
	
	return OK;
}

Status Pop(SqStack &S, SElemType &e){
	//栈空
	if (S.top == S.base){
		return ERROR;
	}
	//栈顶元素被忽略，读取后栈顶指针下移
	e = *--S.top;

	return OK;
}

Status Matching(SqStack &S, char expression[]){
	//"a+b/c-(d*e+f)*g"
	//abc/+de*f+g*-
	int index, flag = 0;
	char e;
	for (index = 0; expression[index] != ''; index++){
		switch (expression[index]){
		case '+':
		case '-':
			flag = 1;
			GetTop(S, e);
			if (StackLength(S) == 0 || e == '(' ){
				//入栈
				Push(S, expression[index]);
				break;
			}
			else{
				//出栈
				while (Pop(S, e)){
					printf("%c ", e);
					GetTop(S, e);
					//栈空时退出循环
					//出栈并不是全出，只在前面的优先级小的时候出，直到够大的时候，就push()
					if (StackLength(S) == 0 || e == '('){
						Push(S, expression[index]);
						flag = -1;
						break;
					}
				}
				if (flag == 1){
					Push(S, expression[index]);
				}
				break;
			}
		case '*':
		case '/':
			flag = 1;
			GetTop(S, e);
			if (StackLength(S) == 0 || e == '(' || e == '+' || e == '-'){
				//入栈
				Push(S, expression[index]);
				break;
			}
			else{
				//出栈
				while (Pop(S, e)){
					printf("%c ", e);
					GetTop(S, e);
					//栈空时退出循环
					Push(S, expression[index]);
					flag = -1;
					break;
				}
				if (flag == 1){
					Push(S, expression[index]);
				}
				break;
			}
		case '(':
			flag = 1;
			Push(S, expression[index]);
			break;
		case ')':
			flag = 1;
			if (StackLength(S)){
				while (Pop(S, e)){
					//栈空时退出循环
					printf("%c ", e);
					GetTop(S, e);					
					if (e == '('){
						Pop(S, e);
						break;
					}
				}
				break;
			}
			else
				return ERROR;
		default:
			printf("%c ", expression[index]);
		}
	}

	if (StackLength(S) != 0){
		while (Pop(S, e)){
			printf("%c ", e);
		}
	}

	return OK;
}