后缀表达式的计算

       后缀表达式的计算

  前面的中缀表达式转后缀表达式中详细介绍了转换的方法。在这篇文章中将介绍后缀表达式的计算(注：以计算0~9的数为例)。

计算过程：

                   (1)初始化一个栈

                   (2)依次读取后缀表达式中的每个字符：

                        p: 若读取到的字符为数字，则数字直接进栈。

                        q:若读到的是运算符，则弹出栈顶的两个元素进行相应的运算，运算结果压入栈中。

                   (3)返回栈顶元素，即最终的结果。

例：1243-*+

     char c='1';

     数字直接进栈：

1

     char c='2'、'3'、'4'同理:

3

4

2

1

     char c='-';

     弹出栈顶的两个元素3、4。注意：在弹出时被减(加、乘、除)数先被弹出，所以结果=第二次弹出的数 - 第一次弹出的数（4-3=1）。计算结果再入栈：

1

2

1

    char c='*';

    弹出栈顶的两个元素1、2。注意：在弹出时被乘(加、减、除)数先被弹出，所以结果=第二次弹出的数  *  第一次弹出的数（2*1=2）。计算结果再入栈：

2

1

     char c='+';

     弹出栈顶的两个元素2、1。注意：在弹出时被加(减、乘、除)数先被弹出，所以结果=第二次弹出的数  - 第一次弹出的数（1+2=3）。计算结果再入栈：

3

     后缀数组读完，弹出栈顶元素，即最终结果：3

/* 后缀表达式计算
	 * char[] postfix:后缀数组
	 */
	public static int postfixEval(char[] postfix){
		LinkedList<Integer> st=new LinkedList();//初始化栈
		for(int i=0;i<index;i++){
			char c=postfix[i];//依次读后缀数组中的各个元素
			if(c>='0'&&c<='9')
				st.push(c-'0');//数字进栈
			else{
				int x,y;
				int val=0;
				
				x=st.pop();//弹出第二个操作数
				y=st.pop();//弹出第一个操作数
				
				switch(c){
				    case '+':    val=y+x;break;
				    case '-':    val=y-x;break;//注意:y才是第一个操作数
				    case '*':    val=y*x;break;
				    case '/':    val=y/x;break;
				}
				
				st.push(val);//计算结果进栈,供下一次操作使用
			}
		}
		return st.pop();//返回最终结果
	}

完整代码：

import java.util.*;
public class 中缀转后缀并计算 {
	private static int index;
	public static void main(String[] args) {
		System.out.println("请输入中缀表达式:");
		Scanner sc=new Scanner(System.in);
		char[] infix=sc.nextLine().toCharArray();
		char[] postfix=new char[infix.length];
		infixtopostfix(infix,postfix);
		System.out.println("后缀表达式为:");
		for(int i=0;i<index;i++){
			System.out.print(postfix[i]);
		}
		System.out.println();
		System.out.println("后缀表达式计算结果为:"+postfixEval(postfix));
	}

	/* 中缀表达式转后缀表达式,结果保存在postfix数组中
	 * char[] infix:前缀数组。char[] postfix:后缀数组
	 */
	private static void infixtopostfix(char[] infix, char[] postfix) {
		index=0;//索引
		LinkedList<Character> st=new LinkedList();//LinkedList对象以push形式添加元素时做堆栈用,以add形式添加元素时做队列用
		
		for(int i=0;i<infix.length;i++){
			char c=infix[i];//获取前缀数组的各个字符
			if(c=='(')
				st.push(c);//左括号直接进栈
			else if(c==')'){
				while(st.peek()!='('){//记录下左右括号内的操作符
					postfix[index++]=st.pop();//碰到右括号时,弹出左右括号中的内容
				}
				st.pop();//弹出左括号
			}else{
				if(c>='0'&&c<='9')
					st.push(c);//数字直接进栈
				else{
					while(!st.isEmpty()&&precedence(st.peek(),c)>=0){//栈不为空&&上一个操作符的优先级高于当前操作符c
						postfix[index++]=st.pop();//弹出的元素记录在后缀数组中
					}
					
					st.push(c);//当前操作符一定要进栈,并在下一层循环或最后弹出
				}
			}
		}
		
		//弹出栈中剩余的操作符
		while(!st.isEmpty()){
			postfix[index++]=st.pop();//弹出的元素记录在后缀数组中
		}
	}
	
	/*
	 * 比较两个操作符的优先级,
	 * char post:栈顶元素。char c:当前读到的元素
	 * 返回1:上一个操作符的优先级高于当前操作符c的优先级,返回0:两个操作符的优先级相同,返回-1:上一操作符的优先级低于当前操作符c
	 */
	private static int precedence(char post, char c) {
		if(post=='(')
			return -1;//上一个操作符为')',返回-1,操作符进栈
		if(post=='+'||post=='-'){
			if(c=='*'||c=='/')//‘+’、‘-’优先级低于‘*’、‘/’return -1
				return -1;
			else
				return 0;//c同为'+'或'-'优先级相同,return 0
		}else if(post=='*'||post=='/'){
			if(c=='+'||c=='-')
				return 1;
			else 
				return 0; 
		}
		return 0;//栈顶元素为数字,操作数与操作符比较返回0
	}
	
	/* 后缀表达式计算
	 * char[] postfix:后缀数组
	 */
	public static int postfixEval(char[] postfix){
		LinkedList<Integer> st=new LinkedList();//初始化栈
		for(int i=0;i<index;i++){
			char c=postfix[i];//依次读后缀数组中的各个元素
			if(c>='0'&&c<='9')
				st.push(c-'0');//数字进栈
			else{
				int x,y;
				int val=0;
				
				x=st.pop();//弹出第二个操作数
				y=st.pop();//弹出第一个操作数
				
				switch(c){
				    case '+':    val=y+x;break;
				    case '-':    val=y-x;break;//注意:y才是第一个操作数
				    case '*':    val=y*x;break;
				    case '/':    val=y/x;break;
				}
				
				st.push(val);//计算结果进栈,供下一次操作使用
			}
		}
		return st.pop();//返回最终结果
	}
}