中序转为前序与后序

一.中序—>前序

1.步骤：

（1）从右到左读进中序表达式的每个字符

（2）如果读进的字符为操作数，则直接输出到前序表达式中

（3）如果遇到“（”，则弹出堆栈内的运算符，直到弹出一个“）”，两者相互抵消

（4）“）”的优先级在堆栈内比任何运算符都小，不过在堆栈外却是优先级最高者

（5）当运算符准备进入堆栈内时，必须和栈顶运算符比较，如果外面的运算符优先级高于或等于栈顶运算符，则压入栈中

如果优先级低于栈顶运算符，就把栈顶运算符弹出，直到栈顶运算符优先级低于外面运算符或堆栈为空，就再把外面这个运算符压入栈中。

（6）中序表达式读完后，如果运算符堆栈不为空，则将期内的运算符逐一弹出，输出到前序表达式中即可。

例：（A+B）*D+E/(F+A*D)+C

用堆栈法转换为前序表达式步骤

读入字符	运算符堆栈中内容	输出
None	Empty	None
C	Empty	C
+	+	C
)	)+	C
D	)+	DC
*	*)+	DC
A	*)+	ADC
+	+)+	*ADC
F	+)+	F*ADC
(	+	+F*ADC
/	/+	+F*ADC
E	/+	E+F*ADC
+	++	/E+F*ADC
D	++	D/E+F*ADC
*	*++	D/E+F*ADC
)	)*++	D/E+F*ADC
B	)*++	BD/E+F*ADC
+	+)*++	BD/E+F*ADC
A	+)*++	ABD/E+F*ADC
(	*++	+ABD/E+F*ADC
None	Empty	++*+ABD/E+F*ADC

2.编码实现

二、中序—>后序

1.步骤

（1）从左到右读入中序表达式每个字符

（2）如果读进的字符为操作数，则直接输出到后序表达式中

（3）如果遇到“）”，则弹出堆栈内的运算符，直到弹出到一个“（”两者互相抵消

（4）“（”的优先级在堆栈内比任何运算符都小，在堆栈外却是优先级最高者。

（5）当运算符进栈时，如果外面的运算符高于栈顶运算符，则压入栈中，

如果优先级低于或等于栈顶运算符就把栈顶运算符弹出，直到栈顶运算符优先级低于外面运算符或堆栈为空，就把外面运算符压入栈中

（6）中序表达式读完后，如果运算符堆栈不为空·，则将期内的运算符逐一弹出。

 

代码展示（中序->后序）：

#include <stdio.h>
#include <stdlib.h>
#define MAX 50
char infix_q[MAX]; 
int compare(char stack_o, char infix_o); 
void infix_to_postfix();    
/*运算符优先权的比较，若输入运算符小于堆栈中的运算符*/
/*，则返回值为1，否则为0                          */

/*主函数声明*/
int main () 		
{ 
    int i=0;
    for (i=0; i<MAX; i++)
	infix_q[i]='\0';	
	printf("\t------------------------------------------\n");
	printf("\t中序表达式转成后序表达式\n");
    printf("\t可以使用的运算符包括:^,*,+,-,/,(,)等 \n");
    printf("\t------------------------------------------\n");
    printf("\t请开始输入中序表达式: ");
    infix_to_postfix();
    printf("\n");
    printf("\t--------------------------------------------\n");
    system("pause");      
    return 0; 
}
int compare(char stack_o, char infix_o)
{
/*在中序表示法的队列和暂存堆栈中，运算符的优先级表，*/
/*其优先权值为INDEX/2                               */
    char infix_priority[9] ; 
	char stack_priority[8] ;
	int index_s=0, index_i=0;
	infix_priority[0]='q';infix_priority[1]=')';
	infix_priority[2]='+';infix_priority[3]='-';
	infix_priority[4]='*';infix_priority[5]='/';
	infix_priority[6]='^';infix_priority[7]=' ';
	infix_priority[8]='(';      
	stack_priority[0]='q';stack_priority[1]='(';
	stack_priority[2]='+';stack_priority[3]='-';
	stack_priority[4]='*';stack_priority[5]='/';
	stack_priority[6]='^';stack_priority[7]=' ';
	while (stack_priority[index_s] != stack_o)
		index_s++;
	while (infix_priority[index_i] != infix_o)
		index_i++;
	return ((int)(index_s/2) >= (int)(index_i/2) ? 1 : 0);
}
void infix_to_postfix()
{
	int rear=0, top=0, flag=0,i=0;
	char stack_t[MAX];  
	for (i=0; i<MAX; i++)
			stack_t[i]='\0';
	    gets(infix_q);
	    i=0;
	    while(infix_q[i]!='\0') 
	    {
          i++;
          rear++;
        }
		infix_q[rear] = 'q';  
		printf("\t后序表示法 : ");
		stack_t[top]  = 'q';  
		for (flag = 0; flag <= rear; flag++)\
        {		
			switch (infix_q[flag]) 
            {
				/*输入为)，则输出堆栈内运算符，直到堆栈内为(*/
				case ')':
					while(stack_t[top]!='(') 			      
						printf("%c",stack_t[top--]);				   
					top--;
					break;
				/*输入为q，则将堆栈内还未输出的运算符输出*/
				case 'q':
					while(stack_t[top]!='q')
						printf("%c",stack_t[top--]);
					break;
				/*输入为运算符，若小于TOP在堆栈中所指运算符，*/
                /*则将堆栈所指运算符输出，若大于等于TOP在堆栈*/
                /*中所指运算符，则将输入运算符压入堆栈     */
				case '(':
				case '^':
				case '*':
				case '/':
				case '+':
				case '-': 
					while (compare(stack_t[top], infix_q[flag])==1)                       
						printf("%c",stack_t[top--]);			
					stack_t[++top] = infix_q[flag];
					break;
				/*输入为操作数，则直接输出*/
				default :
					printf("%c",infix_q[flag]);
					break;
			}
		}
}