转换后缀表达式

3.0版本

// 原作者：庞有伟

#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[]);
Status IsValid(char expression[]);
int StackLength(SqStack S);

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

	char expression[20];
	printf("以下是表达式的转换
");
	//char expression[] = "a+b/c-(d*e+f)*g";
	printf("请输入表达式:
");
	scanf("%s", expression);
	IsValid(expression);
	printf("后缀表达式为:
");
	Matching(S, expression);
	printf("
");
	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;
}

Status IsValid(char expression[]){
	int index_isvalid;
	for (index_isvalid = 1; expression[index_isvalid] != ''; index_isvalid++){
		if (expression[index_isvalid - 1] == expression[index_isvalid]){
			printf("请不要输入连续相同的多个字符
");
			exit(ERROR);
		}
		if (!((expression[index_isvalid] >= 'a' && expression[index_isvalid] <= 'z') ||
			(expression[index_isvalid] >= 'A' && expression[index_isvalid] <= 'Z') ||
			(expression[index_isvalid] >= '0' && expression[index_isvalid] <= '9') ||
			expression[index_isvalid] == '+' || expression[index_isvalid] == '-' ||
			expression[index_isvalid] == '*' || expression[index_isvalid] == '/')){
			printf("请不要输入非表达式合法字符
");
			exit(ERROR);
		}
	}

	return OK;
}

2.0版本

#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);

	char expression[20];
	printf("以下是表达式的转换
");
	//char expression[] = "a+b/c-(d*e+f)*g";
	printf("请输入表达式:
");
	scanf("%s", expression);
	printf("后缀表达式为:
");
	Matching(S, expression);
	printf("
");
	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;
}

1.0版本

/*
栈采用顺序栈存储，试设计算法实现将表达式转换成后缀表达式输出。
例如，输入表达式：   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;
}