java 栈实现算数表达式

1.java实现顺序栈

package util;

/*
 * 栈的实现
 */


public class SeqStack {
	//定义栈的初始化大小
	private int maxSize=10;
	//表示增加量
	private int addSize=1;
	
	//栈
	private Object[] stack=null;
	//栈顶 栈底
	private int top;
	private int base;
	
	
	//构造方法重载
	public SeqStack() {
		//直接初始化栈
		initStack();
	}
	
	//初始化栈
	private void initStack() {
		//分配容量
		stack=new Object[maxSize];
		//初始化栈顶栈底指针
		base=top=0;
	}
	
	//入栈
	public  void push(Object obj) {
		//栈已经满了
		if(top>=maxSize) {
			//扩充栈
			maxSize=maxSize+addSize;
			Object[] temp=new Object[maxSize];
			stack=null;
			stack=temp;
		}else {
			//入栈
			stack[top++]=obj;
		}
	}
	
	//出栈
	public Object pop() {
		Object obj=null;
		if(isEmpty()) {
			System.out.println("栈为空");
		}else {
			//出栈
			obj=stack[--top];
		}
		return obj;
	}
	
	//取栈顶元素
	public Object getTop() {
		Object topData=null;
		if(isEmpty()) {
			System.out.println("栈为空");
		}else {
			topData=stack[top-1];
		}
		return topData;		
	}
	
	//判断栈是否为空
	public boolean isEmpty() {
		if(base==top) {
			return true;
		}
		return false;
	}
	
	//销毁栈
	public void destoryStack() {
		stack=null;
		base=top=0;
	}
	
	//打印栈
	public void print() {
		if(isEmpty()) {
			System.out.print("栈为空");
		}else {
			for(int i=0;i<top;i++) {
				System.out.print(stack[i]+"\t");
			}
		}
	}
}

2.使用逆波兰表达式，将中缀转化为后缀表达式

建议先看一下逆波兰表达式的原理 https://www.cnblogs.com/hantalk/p/8734511.html

package util;

import java.util.ArrayList;
import java.util.List;

import util.*;

/*
 * 中缀表达式转化为后缀表达式
 */

public class ChangeStyle {
	//字符串拆分为单个字符
	private char[] oldStrs;
	//用来存放输出的字符
	private String[] newStrs;
	
	private List<String> list;
	
	//构造方法重载（将输入的字符串转化为字符数组)
	public ChangeStyle(String oldString) {
		oldStrs=oldString.replace(" ", "").toCharArray();
		charToStringArray();
	}	
	
	//字符数组转化为字符串数组
	private void charToStringArray() {
		StringBuffer sb=new StringBuffer();
		list=new<String> ArrayList();
		//for循环
		for(int i=0;i<oldStrs.length;i++) {
			//如果为符号直接添加到list中
			if(oldStrs[i]=='+'||oldStrs[i]=='-'||oldStrs[i]=='*'||oldStrs[i]=='/'||oldStrs[i]=='('||oldStrs[i]==')') {
				//把非符号位添加到list中
				if(sb!=null&&!(sb.toString().equals(""))) {
					list.add(sb.toString());
					sb=new StringBuffer();
				}
				list.add(String.valueOf(oldStrs[i]));
			}else {
				sb.append(String.valueOf(oldStrs[i]));
				if(i+1>=oldStrs.length) {
					list.add(sb.toString());
				}
			}
		}
		//初始化newStrs数组，后边转化为后缀表达式用
		newStrs=new String[list.size()];
	}
	
	//处理数组，转化为后缀表达式
	public String[] dealThisChar() {
		//创建栈
		SeqStack stack=new SeqStack();
		//计数器
		int count=0;
		//利用for循环
		for(String c:list) {
			switch(c) {
			//加减的优先级相同，所以方法是一样的
			case "+":
			case "-":
				while(!stack.isEmpty()) {
					String top=(String)stack.getTop();
					if(!top.equals("(")) {
						newStrs[count++]=(String)stack.pop();
					}else {
						//如果为‘（’，直接压入栈中
						stack.push(c);
						break;
					}
				}	
				//栈为空，直接压入
				if(stack.isEmpty()) {
					stack.push(c);
				}
				break;
			//（乘除）的优先级相同
			case "*":
			case "/":
				//栈不为空的时候
				while(!stack.isEmpty()) {
					String top=(String)stack.getTop();
					//如果栈顶是+、-或者（时候，直接压入栈中
					if(top.equals("+")||top.equals("-")||top.equals("(")) {
						stack.push(c);
						break;
					}else {
						//出栈
						newStrs[count++]=(String)stack.pop();
					}
				}	
				//上述条件判断完后如果栈还未空，则直接将c压栈中
				if(stack.isEmpty()) {
					stack.push(c);
				}
				break;
			//左括号直接压入栈中
			case "(":
				stack.push(c);
				break;
			//有括号，需要直接出栈，直到左括号出来
			case ")":
				while(!stack.isEmpty()) {
					String top=(String)stack.getTop();
					if(!top.equals("(")) {
						newStrs[count++]=(String)stack.pop();
					}else {
						stack.pop();
						break;
					}
				}				
				break;
			default:newStrs[count++]=c;
			}
		}
		//如果最后栈中还有元素，全部出栈，添加到最后
		while(!stack.isEmpty()) {
			newStrs[count++]=(String)stack.pop();
		}
		//销毁栈
		stack.destoryStack();
		return newStrs;
	}
}

3.计算

package enterance;

import util.ChangeStyle;
import util.SeqStack;
import java.util.Scanner;

public class Main {
	private static String[] newStr;
	public static void main(String []args) {
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入表达式:");
		String input=scanner.nextLine();
		ChangeStyle changeStyle=new ChangeStyle(input);
		newStr=changeStyle.dealThisChar();
		System.out.print("计算结果为"+count());
	}
	
	//计算
	/*
	 * newStr为后缀表达式，后缀表达式求值思想
	 * 非符号直接仍入到栈中
	 * 遇到符号，从栈中取出来两位 做运算
	 */
	private static String count() {
		int first;
		int second;
		int value;
		//实例化栈
		SeqStack stack=new SeqStack();
		String c;
		for(int i=0;i<newStr.length;i++) {
			if((c=newStr[i])!=null) {
			switch(c) {
			case "+":
				//栈中取出来两位
				first=Integer.parseInt((String)stack.pop());
				second=Integer.parseInt((String)stack.pop());
				value=first+second;
				stack.push(String.valueOf(value));
				 break;
			case "-":
				//栈中取出来两位
				first=Integer.parseInt((String)stack.pop());
				second=Integer.parseInt((String)stack.pop());
				value=second-first;
				stack.push(String.valueOf(value));
				 break;
			case "*":
				//栈中取出来两位
				first=Integer.parseInt((String)stack.pop());
				second=Integer.parseInt((String)stack.pop());
				value=second*first;
				stack.push(String.valueOf(value));
				 break;
		
			case "/":
				//栈中取出来两位
				first=Integer.parseInt((String)stack.pop());
				second=Integer.parseInt((String)stack.pop());
				value=second/first;
				stack.push(String.valueOf(value));
				 break;
			//数字全部压入栈中
			default:stack.push(c);
			}
			}
		}	
		return (String)stack.pop();
	}
}