【数据结构算法】如何使用栈计算后缀表达式

无聊写的一个使用栈计算后缀表达式的代码：

初次写，只有+-*/四个运算符，后面可以自己加，都差不多就是个算术运算符优先级的问题。

主函数：包括初始化*+-/符号，判断输入的字符是操作数还是运算符。

/**
 * !!!!!（栈相关测试）
 * @author WZ
 *
 */
package MyCollection;

public class Test01 {
	/**
	 * 使用栈计算后缀表达式
	 * 
	 * @author WZ
	 *
	 */
	class CalPostfixExpressionByStack {

		private static final char ADD = '+';
		private static final char SUB = '-';
		private static final char MUL = '*';
		private static final char DEV = '/';

		MyStack stack1;

		public CalPostfixExpressionByStack() {
			stack1 = new MyStack();
		}

		public Object Scan(String expr) {
			int op1 = 0;
			int op2 = 0, result = 0;
			String token;
			Scanner scanner = new Scanner(expr);
			// System.out.println(scanner.next().charAt(1));
			while (scanner.hasNext()) {
				token = scanner.next();// next()不回录入空格
				if (isOperator(token)) {
//					if (stack1.peek() instanceof Integer) {这里是错误的，因为栈中的其他元素依然是String对象，String对象无法强转成为Integer。
//						op1=(Integer) stack1.pop();
//						op2=(Integer) stack1.pop();
//					}
						op1 = (int) stack1.pop();
						op2 = (int) stack1.pop();				
					result = CalSingleOperator(token.charAt(0), op1, op2);
					stack1.push(result);
				} else {
					if (token instanceof String) {
						stack1.push(Integer.parseInt(token));//只要读入的的是String对象，直接转成Integer对象，避免后面的运算混乱
						
					}
				}
			}
			return result;

		}

		public int CalSingleOperator(char operator, int op1, int op2) {
			int result = 0;
//			Integer opp1=Integer.valueOf((String) op1);
//			Integer opp2=Integer.valueOf((String) op2);
//			Number number1 = (Number) op1;
//			Number number2 = (Number) op2;
//			int opp1 = number1.intValue();
//			int opp2 = number2.intValue();
			switch (operator) {
			case ADD:
				result = op2 + op1;
				break;
			case SUB:
				result = op2 - op1;
				break;
			case MUL:
				result = op2 * op1;
				break;
			case DEV:
				result = op2 / op1;
				break;

			default:
				break;
			}
			return result;
		}

		public boolean isOperator(String token) {
			return (token.equals("+") || token.equals("-") || token.equals("*") || token.equals("/"));
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// MyStack m=new MyStack();
		// char c='*';
		// m.push(c);
		// System.out.println(m.pop());
		/
		// String[] s1={"111","2222","333"};
		Test01 t1 = new Test01();
		// QueueWithTowStack queueWithTowStack=t1.new QueueWithTowStack();
		// for (int i = 0; i < s1.length; i++) {
		// queueWithTowStack.enQueue(s1[i]);
		// }
		//
		// queueWithTowStack.isEmpty();
		// System.out.println(queueWithTowStack.deQueue());
		// System.out.println(queueWithTowStack.deQueue());
		// System.out.println(queueWithTowStack.deQueue());
		///
		String exression;
		Object result;
		Scanner scanner = new Scanner(System.in);

		CalPostfixExpressionByStack c = t1.new CalPostfixExpressionByStack();
		System.out.println("请输入一个后缀表达式：");
		System.out.println("例如123*+5-");
		exression = scanner.nextLine();
		result = c.Scan(exression);
		System.out.println("结果为：" + result);
	}

}

自己定义的Stack，有基本的功能就够了......本人懒水平也不是很高。。。。

package MyCollection;

public class MyStack {
	private Object[] objects;
	private int top;
	
	public MyStack() {
		this(10);
	}
	
	public MyStack(int maxsize) {
		objects=new Object[maxsize];
		top=0;
	}
	
	public void push(Object obj) {
		objects[top++]=obj;
	}
	
	public Object pop() {
		return objects[--top];
	}
	
	public boolean isEmpty() {
		return top==0; 
	}
	
	public void disPlay() {
		for (int i = top-1; i >=0; i--) {
			System.out.println(objects[i]);
		}
	}
	
	public Object peek() {
		return objects[top-1];
	}
	
	public int size(){
		return top;
	} 
	public Object[] getObjects() {
		return objects;
	}
	public void setObjects(Object[] objects) {
		this.objects = objects;
	}
}

最后是一个输出(哈哈哈哈火火吼吼...) 

请输入一个后缀表达式：
例如123*+5-
1 2 3 * + 5 -
结果为：2

 

就这么多了。。