中缀表达式转换成逆波兰式

---

编写程序，将任意一个合法的中缀表达式转换成逆波兰式。

【问题描述】表达式计算是实现程序设计语言的基本问题之一。在计算机中进行算术表达式的计算可通过栈来实现。通常书写的算术表达式由操作数、运算符以及圆括号连接而成。为简便起见，本题只讨论双目运算符。

算术表达式的两种表示如下：
⑴ 中缀表达式：把双目运算符出现在两个操作数中间的表示，称为算术表达式的中缀表示。中缀表示的算术表达式，称为中缀算术表达式，也称中缀表达式。如表达式2+5*6就是中缀表达式。
⑵ 后缀表达式：中缀表达式的计算比较复杂。能否把中缀表达式转换成另一种形式的表达式，使计算简单化呢？波兰科学家卢卡谢维奇(Lukasiewicz)提出了算术表达式的另一种表示，即后缀表式，又称逆波兰式。

逆波兰式即是将算术表达式用后缀方法表示，即，把运算符放在两个运算对象的后面。逆波兰式也称后缀算术表达式，或后缀表达式。在逆波兰式中，不存在括号，也不存在优先级的差别，计算过程完全按运算符出现的先后次序进行，整个计算过程仅需一遍扫描便可完成，比中缀表达式的计算简单。

例如，12!4!-!5!/就是一个逆波兰式。其中’!’表示操作数间的空格，因减法运算符在前，除法运算符在后，所以应先做减法，后做除法；减法的两个操作数是它前面的12和4，其中第一个数12是被减数，第二个数4是减数；除法的两个操作数是它前面的12减4的差(即8)和5，其中8是被除数，5是除数。

请查阅中缀表达式转换成对应的后缀算术表达式的规则，完成本题。 表1是一些中缀表达式与后缀表达式对应的例子：
表1 中缀表达式与对应的逆波兰式

中缀表达式	后缀表达式
3/5+6	3!5!/!6!+
16-9*(4+3)	16!9!4!3!+!*!-

【假设条件】本题应对输入的中缀表达式，输出其对应的逆波兰式。假定表达式一定是合法的，且其中的数字均为1位整数，运算符包括：+，-，*，/，（，）。输入输出均为字符串形式。

可以如下形式实现：void InfixToPostfix(char *infix, char posfix)；

---

这题是栈的应用，趁老师上课才讲了算法，自己回顾一遍，写一写代码实现。

---

准备工作要做好：
1.两个栈S1、S2，S1用来存放操作符，S2用来存放逆波兰式。我是用c语言写的，栈和栈的相关操作就要先写好，备用。
2.把中缀表达式（infix数组）的头尾都加上元素#（#是我自定的结束符，当两个#相遇，说明中缀表达式已经处理完了）
说明一下：实际处理infix数组时，我只在它的末尾加了#，另一个#事先压入了S1栈。
3.准备一个可以比较两个操作符优先级的功能函数。
操作符优先级顺序：# < + or - < * or /

---

大致思路：

'#'入S1栈

遍历中缀表达式，当前字符：
1.如果是操作数，直接入S2栈
2.如果是操作符，比较当前操作符op2和S1栈顶的操作符op1优先级大小。若op2>op1，op2入S1栈；否则取出op1（弹栈），压入S2栈。
3.如果是(，直接入S1栈。
4.如果是），弹出S1栈中距离栈顶最近的（之后的元素，舍弃 ( 。例如：S1为 # * ( - ，此时遇到了 ) ，S1变为 # *。
5.如果是#，且S1栈顶为#，遍历结束，退出循环。

遍历完成后，栈S2就存放了转换后的逆波兰式。

---

代码实现：

1.栈和栈的相关操作

struct stack
{
	char ele[MAXSIZE];
	int top;
};
void push(struct stack* stack, char val)
{
	stack->ele[(stack->top)++]=val;
} 
char pop(struct stack* stack)
{
	char e;
	e = stack->ele[--(stack->top)];
	return e;
}
char looktop(struct stack* stack)
{
	return stack->ele[(stack->top)-1];
} 

2.比较优先级的函数

int priority(char op1, char op2)//op2优先级大于op1，返回1，否则返回0； 
{
	if(op1=='#'||op1=='('||((op1=='+'||op1=='-')&&(op2=='*'||op2=='/')))
		return 1;
	else
		return 0;
}

3.转换过程

for(i=0;;i++)//遍历中缀表达式 
	{
		if(infix_new[i]=='#')//遇到结束符，取出stack_op栈中#和#间的操作符，压入stack_ob栈中，停止遍历 
		{
			push(stack_ob, pop(stack_op));
			break;
		} 
		if(infix_new[i]>='0'&&infix_new[i]<='9')//字符为操作数，压入stack_ob栈中
		{
			push(stack_ob, infix_new[i]);
			push(stack_ob, '!');
		}
		else if(infix_new[i]=='+'||infix_new[i]=='-'||infix_new[i]=='*'||infix_new[i]=='/')//字符为操作符，比较优先级 
		{
			if(priority(looktop(stack_op), infix_new[i])==1)//操作符优先级大于stack_op栈顶操作符优先级，入栈 
				push(stack_op, infix_new[i]);
			else//操作符优先级小于等于stack_op栈顶操作符优先级，取出stack_op栈顶操作符，压入stack_ob栈中
			{
				push(stack_ob, pop(stack_op));
				push(stack_ob, '!');
				i--;
			}
		} 
		else if(infix_new[i]=='(')//字符为左括号，直接入stack_op栈 
		{
			push(stack_op, infix_new[i]);
		}
		else if(infix_new[i]==')')//字符为右括号，取出距离stack_op栈顶最近的'('之后的运算符，逐个出栈，依次压入stack_ob栈，丢弃'(' 
		{
			while(1)
			{
				if(looktop(stack_op)=='(')
				{
					pop(stack_op);
					break;
				}
				else
				{
					push(stack_ob, pop(stack_op));
					push(stack_ob, '!');
				}
			}
		}
	}

4.完整的代码实现

#include
#include
#define MAXSIZE 1024
struct stack
{
	char ele[MAXSIZE];
	int top;
};
void push(struct stack* stack, char val)
{
	stack->ele[(stack->top)++]=val;
} 
char pop(struct stack* stack)
{
	char e;
	e = stack->ele[--(stack->top)];
	return e;
}
char looktop(struct stack* stack)
{
	return stack->ele[(stack->top)-1];
} 
int priority(char op1, char op2)//op2优先级大于op1，返回1，否则返回0； 
{
	if(op1=='#'||op1=='('||((op1=='+'||op1=='-')&&(op2=='*'||op2=='/')))
		return 1;
	else
		return 0;
}
void InfixToPostfix(char *infix, char *posfix)
{
	char *infix_new;
	int i; 
	struct stack *stack_op, *stack_ob;
	//创建两个栈：一个存放操作符，一个存放逆波兰式表达式 
	stack_op = (struct stack*)malloc(sizeof(struct stack));
	stack_ob = (struct stack*)malloc(sizeof(struct stack));
	stack_op->top=0;
	stack_ob->top=0;
	for(i=0;infix[i];i++); 
	infix_new = (char*)malloc(sizeof(char)*(i+2));
	for(i=0;;i++)//给中缀表达式末尾加上结束符'#' 
	{
		if(infix[i]=='\0')
		{
			infix_new[i]='#';
			infix_new[i+1]='\0';
			break;
		}
		infix_new[i] = infix[i]; 
	}
	push(stack_op, '#');
	for(i=0;;i++)//遍历中缀表达式 
	{
		if(infix_new[i]=='#')//遇到结束符，取出stack_op栈中#和#间的操作符，压入stack_ob栈中，停止遍历 
		{
			push(stack_ob, pop(stack_op));
			break;
		} 
		if(infix_new[i]>='0'&&infix_new[i]<='9')//字符为操作数，压入stack_ob栈中
		{
			push(stack_ob, infix_new[i]);
			push(stack_ob, '!');
		}
		else if(infix_new[i]=='+'||infix_new[i]=='-'||infix_new[i]=='*'||infix_new[i]=='/')//字符为操作符，比较优先级 
		{
			if(priority(looktop(stack_op), infix_new[i])==1)//操作符优先级大于stack_op栈顶操作符优先级，入栈 
				push(stack_op, infix_new[i]);
			else//操作符优先级小于等于stack_op栈顶操作符优先级，取出stack_op栈顶操作符，压入stack_ob栈中
			{
				push(stack_ob, pop(stack_op));
				push(stack_ob, '!');
				i--;
			}
		} 
		else if(infix_new[i]=='(')//字符为左括号，直接入stack_op栈 
		{
			push(stack_op, infix_new[i]);
		}
		else if(infix_new[i]==')')//字符为右括号，取出距离stack_op栈顶最近的'('之后的运算符，逐个出栈，依次压入stack_ob栈，丢弃'(' 
		{
			while(1)
			{
				if(looktop(stack_op)=='(')
				{
					pop(stack_op);
					break;
				}
				else
				{
					push(stack_ob, pop(stack_op));
					push(stack_ob, '!');
				}
			}
		}
	}
	for(i=0;i<stack_ob->top;i++)
	{
		posfix[i] = stack_ob->ele[i];
	}
	posfix[i]='\0';
}

---

完