算法训练 表达式计算 中后缀表达

　　表达式长度不超过100，表达式运算合法且运算过程都在int内进行。

这道题要学习  中缀表达式 --> 后缀表达式 

1-2+3*(4-5)；这叫中缀表达式；

1 2 - 3 4 5 - * + ；这叫后缀表达式，是由上面转换而来的；

先看后缀表达式怎们计算出 -4 的；

后缀表达式算起来很神奇 很方便了；把中缀表达式转换成后缀表达式就行了撒；

以下答案并没有处理数字大于9的情况！

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Stack;


/*1-2+3*(4-5)*/
public class 算法训练表达式计算 {
	static ArrayList<Character> InfixExp = new ArrayList<Character>();//中缀表达式
	static Stack<Character> SuffixStack = new Stack<Character>();//后缀表达式的栈
	static Stack<Character> TempStack = new Stack<Character>();//后缀表达式倒过来的栈
	static Stack<Integer> CalculateStack = new Stack<>();//用于计算后缀表达式的栈;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner input = new Scanner(System.in);
		String a = null;
		if (input.hasNext()) {
			a = input.nextLine();
		}
		char[] infix = a.toCharArray();
		for (int i = 0; i < a.length(); i++) {
			InfixExp.add(a.charAt(i));
		}
		
		Iterator<Character> iterator = InfixExp.iterator();
//		while (iterator.hasNext()) {
//			Character character = (Character) iterator.next();
//			System.out.print(character+" ");
//		}
		
		TransInfixToSuffix();
		TransSuffixToTemp();
		Calculate();
//		while (!SuffixStack.isEmpty()) {
//			Character temp = SuffixStack.pop();
//			System.out.print(temp+" ");
//		}
//		while (!TempStack.isEmpty()) {
//			Character temp = TempStack.pop();
//			System.out.print(temp+" ");
//		}
		System.out.println(CalculateStack.pop());
	}

	private static void TransSuffixToTemp() {
		// TODO Auto-generated method stub
		while (!SuffixStack.isEmpty()) {
			TempStack.push(SuffixStack.pop());
		}
	}

	private static void Calculate() {
		// TODO Auto-generated method stub
		while (!TempStack.isEmpty()) {
			Character temp = TempStack.pop();
			if (Character.isDigit(temp)) {
				String  a1 =Character.toString(temp);
				int a11 = Integer.valueOf(a1);
				CalculateStack.push(a11);
			}else {
				int a1 = CalculateStack.pop();
				int a2 = CalculateStack.pop();
				if (temp.equals('+')) {
					CalculateStack.push(a2+a1);
				}else if (temp.equals('-')) {
					CalculateStack.push(a2-a1);
				}else if (temp.equals('*')) {
					CalculateStack.push(a2*a1);
				}else {
					CalculateStack.push(a2/a1);
				}
			}
		}
	}

	private static void TransInfixToSuffix() {
		// TODO Auto-generated method stub
		Stack<Character> characters = new Stack<Character>();
		Iterator<Character> iterator = InfixExp.iterator();
		while (iterator.hasNext()) {
			Character character = (Character) iterator.next();
			int i = judge(character);
			switch (i) {
			case 1://数字直接进suffix栈
				SuffixStack.push(character);
				break;
			case 2://（直接进符号栈
				characters.push(character);
				break;
			case 3://碰到右括号
				while (characters.peek()!='(') {
					Character temp = characters.pop();
					SuffixStack.push(temp);
				}
				characters.pop();//把'('弹出去
				break;
			case 4://+和-,不碰到（和栈为空，都要把栈顶的弹出去。因为乘除和加减都满足大于等于这个符号；
				while (!characters.isEmpty()) {
					if (characters.peek()=='+'||characters.peek()=='-'||characters.peek()=='*'||characters.peek()=='/') {
						Character temp = characters.pop();
						SuffixStack.push(temp);
					}
					else {
						break;
					}
				}
				characters.push(character);
				break;
			case 5://乘除号
				while (!characters.isEmpty()) {
					if (characters.peek().equals('+')||characters.peek().equals('-')||characters.peek().equals('(')) {
						break;
					}else if (characters.peek().equals('*')||characters.peek().equals('/')) {
						Character temp = characters.pop();
						SuffixStack.push(temp);
					}
				}
				characters.push(character);
				break;
			default:
				break;
			}
		}
		while (!characters.isEmpty()) {
			Character temp = characters.pop();
			SuffixStack.push(temp);
		}
	}

	private static int judge(Character character) {
		// TODO Auto-generated method stub
		if (Character.isDigit(character)) {
			return 1;//直接入栈
		}else if (character.equals('(')) {
			return 2;//直接入栈
		}else if (character.equals(')')) {
			return 3;
		}else if (character.equals('*')||character.equals('/')) {
			return 5;
		}else {
			return 4;//+和-
		}
		
	}

}