接上篇文章的中缀与后缀的代码实现

代码分为3部分，其实只要两部分的，就是一个测试类和一个计算类。下面看代码：

package lesson.arry;

import java.util.Stack;

public class Calculate {
	
	public int calSuffix(String []str){  //计算后缀表达式的值
		MyStack sk=new MyStack();
		int second,first;
		for(String tmp :str){
			switch(tmp){
				case "+":
					second=sk.pop();
					first=sk.pop();
					sk.push(first+second);
					break;
				case "-":
					second=sk.pop();
					first=sk.pop();
					sk.push(first-second);
					break;
				case "*":
					second=sk.pop();
					first=sk.pop();
					sk.push(first*second);
					break;
				case "/":
					second=sk.pop();
					first=sk.pop();
					sk.push(first/second);
					break;
				default:
					Integer j=Integer.parseInt(tmp);
					sk.push(j);
					break;
			}
		}
		return sk.pop();
	}
	public void infixToSuffix(String []source,String []destination){  //中缀表达式变换为后缀表达式
		int index=0;
		Stack<String> sk=new Stack<String>();
		for(String tmp:source){
			switch(tmp){
			case "+":
			case "-": //因为+ -它们的优先级是一样的，可以放一起处理
				if(!sk.empty() && sk.peek()=="(")  //只有左括号优先级比+号低    加号和减号优先级一样
					sk.push(tmp);
				else{
					while(!sk.empty() && sk.peek()!="("){
						destination[index++]=sk.pop();
					}
					sk.push(tmp);
				}
				break;
			case "*":
			case "/":
				if(!sk.empty() && sk.peek()!="/" && sk.peek()!="*")  //只有左括号优先级比+号低    加号和减号优先级一样
					sk.push(tmp);
				else{
					while(!sk.empty() && (sk.peek()=="/" || sk.peek()=="*")){
						destination[index++]=sk.pop();
					}
					sk.push(tmp);
				}
				break;
			case "(": //所有的中括号还是大括号都可以换为小括号，所以没必要再去考虑其他复杂的括号
				sk.push(tmp);
				break;
			case ")":
				while(!sk.empty() && sk.peek()!="("){
					destination[index++]=sk.pop();
				}
				sk.pop();  //去除左括号
				break;
			default:
				destination[index++]=tmp;
				break;
			}
//			for(String temp:sk)  //测试用
//				System.out.print(temp);
//			System.out.println();
//			for(String temp:destination)
//				System.out.print(temp);
//			System.out.println();
		}  //结束for循环
		while(!sk.empty()){
			destination[index++]=sk.pop();
		}
	}

	public int calInfix(String[]str){  //计算中缀表达式
		int count=0;
		for(String temp:str){
			if(temp.equals("(")){ //含有括号时后缀表达式要变短
				count++;
			}
		}
		String[]destination=new String[str.length-2*count];
		infixToSuffix(str, destination);//中缀表达式变为后缀表达式
		
		System.out.print("后缀表达式为：");
		for(String temp:destination)  //查看后缀表达式
			System.out.print(temp);
		System.out.println();

		return calSuffix(destination);  //调用后缀表达式
	}
}

上面已经说了，只需要两个类的，为了更加的熟悉栈，所以自己写了一个栈，没java自带的好，勉强能用吧。代码如下：

package lesson.arry;

public class MyStack {
	public int[] datas;
	public int index=-1;
	public MyStack(){
		this(10);  //必须放在最前面
	}
	public MyStack(int size){
		datas=new int[size];
	}
	public void push(int data){
		if(index>=datas.length-1){
			int[] tempArry=new int[datas.length+5];
			System.arraycopy(datas, 0, tempArry, 0, datas.length);
			datas=tempArry;
//			System.gc();  //通知垃圾回收器工作
		}
		index++;
		datas[index]=data;
	}
	
	public int pop(){
		if(index<=-1)
			return 0;
		return datas[index--];
	}
	public boolean isEmpty(){
		return index<=-1;
	}
	
	public int peek(){
		if(index<=-1)
			return 0;
		return datas[index];
	}
/*	
	public static void main(String args[]){
		MyStack ms=new MyStack();
		Calculate ca=new Calculate();
//		for(int i=0;i<30;i++){
//			ms.push((int)(Math.random()*100+1));
//		}
//		while(!ms.isEmpty()){
//			System.out.println(ms.pop());
//		}
		String []str=new String[]{"1","2","3","+","4","*","+"};
		String []str2=new String[]{"1","+","(","2","+","3",")","*","4"};
		try{
			System.out.println(ca.calSuffix(str));
			System.out.println(ca.calInfix(str2));
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	*/
}

两个类都定义完了，接下来就是随便写个类来测试一下：

package lesson.arry;

public class Test {
	public static void main(String[] args) {
		Calculate calculate = new Calculate();
		
		String []str=new String[]{"1","2","3","+","4","*","+"};
		String []str2=new String[]{"1","+",
				"(","2","+","3",")","*","4"}; //1+(2+3)*4
		String []str3=new String[]{"2","+","(","10","+","4","*","2",")",
				"/","2","-","1"}; //2+(10+4*2)/2-1
		try{
			System.out.print("直接使用后缀表达式结果为： ");
			System.out.println(calculate.calSuffix(str));
			System.out.println(calculate.calInfix(str2)); //测试1
			System.out.println(calculate.calInfix(str3)); //测试2
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}

结果都是正确的，想验证的可以拷下去跑一跑，代码肯定有好多的bug，好多地方还没有考虑，比如输入字符要报错啊什么的，这个以后大家再改吧，现在只是简单的提供一下自己的算法，欢迎补充。