说明
- 本程序只实现了基本的四则运算，即加减乘除，不能有括号
- 本程序使用了基本的数据结构之一——栈
源代码
Calculator 这个类是主类，其中用到的ArrayStack 是自定义的类，源代码在后面
public class Calculator {
public static void main(String[] args) {
// 表达式字符串，需要替换成你用的
String exp = "700-400+20*60-40/2*2";
// 数栈和符号栈
ArrayStack numStack = new ArrayStack(20);
ArrayStack operStack = new ArrayStack(20);
int index = 0;
// 运算数和运算符
int num1 = 0;
int num2 = 0;
int oper = 0;
// 中间结果
int result = 0;
char ch = ' ';
// 多位数字字符串
String num="";
// 遍历表达式
while(index < exp.length()) {
// 截取字符
ch = exp.substring(index, index+1).charAt(0);
// 判断该字符是数字还是运算符
if(operStack.isOper(ch)) {
// 判断符号栈是否为空
if(!operStack.isEmpty()) {
// 如果当前运算符的优先级 <= 栈顶运算符的优先级
if(operStack.priority(ch) <= operStack.priority(operStack.peek())) {
// 取出数栈最上面的两个数
num1 = numStack.pop();
num2 = numStack.pop();
// 取出符号栈的栈顶运算符
oper = operStack.pop();
// 进行运算
result = numStack.cal(num1, num2, oper);
// 运算结果入数栈
numStack.push(result);
// 当前运算符入符号栈
operStack.push(ch);
}else {
// 如果当前运算符的优先级 > 栈顶运算符，直接入栈
operStack.push(ch);
}
}else {
// 如果当前符号栈为空，直接入栈
operStack.push(ch);
}
}else {
// 如果是数字，不能直接入栈，因为它可能不止一位
// 拼接字符
num += ch;
// 如果是最后一位数字，就没必要判断了，直接入栈好了
if(index == exp.length()-1) {
numStack.push(Integer.parseInt(num));
}else {
// 判断当前位置的下一位是不是数字，如果是运算符，就可以入栈了；否则继续循环
if( operStack.isOper(exp.substring(index+1,index+2).charAt(0) ) ){
numStack.push(Integer.parseInt(num));
// 然后把字符串清空
num = "";
}
}
}
index++;
} // 表达式遍历结束
// 顺序从数栈和符号栈取出 运算数和运算符进行运算，最终符号栈为空，数栈中只剩下最终结果
while(true) {
if(operStack.isEmpty()) {
break;
}
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
result = numStack.cal(num1, num2, oper);
numStack.push(result);
}
// 输出最终结果
System.out.printf("%s = %d\n", exp, numStack.pop());
} // 主方法结束
} // 类结束
这是ArrayStack 类的源代码
public class ArrayStack{
// 栈的大小
private int maxSize;
// 利用数组模拟栈
private int[] stack;
// 栈顶指针
private int top = -1;
// 构造函数
public ArrayStack(int maxSize) {
this.maxSize = maxSize;
stack = new int[this.maxSize];
}
// 判断栈满
public boolean isFull() {
return top == this.maxSize-1;
}
// 判断栈空
public boolean isEmpty() {
return top == -1;
}
// 入栈dea
public void push(int ele) {
if(isFull()) {
return;
}
top++;
stack[top] = ele;
}
// 出栈
public int pop() {
if(isEmpty()) {
throw new RuntimeException("栈为空！");
}
int value = stack[top];
top--;
return value;
}
// 查看栈顶元素
public int peek() {
if(isEmpty()) {
throw new RuntimeException("栈为空！");
}
return stack[top];
}
// 遍历栈
public void list() {
if(isEmpty()) {
System.out.println("栈为空！");
return;
}
for(int i=top; i>=0; i--) {
System.out.printf("stack[%d]=%d\n", i,stack[i]);
}
}
// 返回运算符优先级
public int priority(int oper) {
if(oper == '*' || oper == '/') {
return 1;
}else if(oper == '+' || oper == '-') {
return 0;
}else {
// 表示非法字符
return -1;
}
}
// 判断是否为运算符
public boolean isOper(char val) {
return val == '+' || val == '-' || val == '*' || val == '/';
}
// 计算
public int cal(int num1,int num2,int oper) {
int result = 0;
switch(oper) {
case '+':
result = num1 + num2;
break;
case '-':
result = num2 - num1; // 注意出栈的顺序与实际顺序是反着的
break;
case '*':
result = num1 * num2;
break;
case '/':
result = num2 / num1;
break;
}
return result;
}
}
运行结果
运行结果
