现代软件工程 第一章 四则运算的实现--栈实现

Posted 2020-08-09

 

像阿超那样，花二十分钟写一个能自动生成小学四则运算题目的命令行 “软件”， 分别满足下面的各种需求。下面这些需求都可以用命令行参数的形式来指定：

    a) 除了整数以外，还要支持真分数的四则运算。 （例如：  1/6 + 1/8 = 7/24）

    b) 让程序能接受用户输入答案，并判定对错。 最后给出总共 对/错 的数量。

    c) 逐步扩展功能和可以支持的表达式类型，最后希望能支持下面类型的题目 （最多 10 个运算符，括号的数量不限制）：
         25 - 3 * 4 - 2 / 2 + 89 = ？
         1/2 + 1/3 - 1/4 = ？ 
        （5 - 4 ） * （3 +28） =？

实现代码如下：

import java.util.Stack;

import java.util.Scanner;
/**
* 利用栈，进行四则运算的类
* 用两个栈来实现算符优先，一个栈用来保存需要计算的数据numStack,一个用来保存计算优先符priStack
*
* 基本算法实现思路为：用当前取得的运算符与priStack栈顶运算符比较优先级：若高于，则因为会先运算，放入栈顶；
* 若等于，因为出现在后面，所以会后计算，所以栈顶元素出栈，取出操作数运算；
* 若小于，则同理，取出栈顶元素运算，将结果入操作数栈。各个优先级‘(‘ > ‘*‘ = ‘/‘ > ‘+‘ = ‘-‘ > ‘)‘
*
*/
public class Operate {
private Stack<Character> priStack = new Stack<Character>();// 操作符栈
private Stack<Integer> numStack = new Stack<Integer>();;// 操作数栈

　　　　private static List list = new ArrayList();//用於存放計算答案
　　　　private static List list1 = new ArrayList();//用於存放用戶輸入答案

//生成真分數表達式
public static String zhen(){
int y = (int) (Math.random()*2)+1;//随机生成运算符的数量
int[] w = new int[10];
String str =null;
if(y==1){
char ch = "+-".charAt((int) (Math.random()*2));
for(int i=0;i<(2*y+2);i++){
w[i]= (int) (Math.random()*9)+1;
}
str = w[0] + "/" + w[1] + ch + w[2] + "/" + w[3] + "=";
return str;
}
if(y==2){
for(int i=0;i<2*y+2;i++){
w[i] = (int) (Math.random()*9)+1;
}
char ch1 = "+-".charAt((int) (Math.random()*2));
char ch2 = "+-".charAt((int) (Math.random()*2));
str = w[0] + "/" + w[1] + ch1 + w[2] + "/" + w[3] + ch2 + w[4] + "/" + w[5] + "=";
return str;
}
if(y==3){

}
return str;
}

//生成整数表达式
public static String zhengshu(){
int y = (int) (Math.random()*1)+2;//随机生成运算符的数量
int[] in = new int[10];
String str =null;
char ch1=0,ch2=0,ch3=0,ch4=0;
if(y==2){
for(int i=0;i<y+1;i++){
in[i] = (int) (Math.random()*30)+1;
}
int num = (int) (Math.random()*2);
if(num==0){//左边加括号
ch1 = "+-".charAt((int) (Math.random()*2));
ch2 = "*/".charAt((int) (Math.random()*2));
str = "(" + in[0] + ch1 + in[1] + ")" + ch2 + in[2] +"=";
}else{
ch1 = "+-".charAt((int) (Math.random()*2));
ch2 = "*/".charAt((int) (Math.random()*2));
str = in[0] + ch2 + "(" + in[1] + ch1 + in[2] + ")" +"=";
}
return str;
}
return str;
}

/**
* 传入需要解析的字符串，返回计算结果(此处因为时间问题，省略合法性验证)
* @param str 需要进行技术的表达式
* @return 计算结果
*/
public int caculate(String str) {
// 1.判断string当中有没有非法字符
String temp;// 用来临时存放读取的字符
// 2.循环开始解析字符串，当字符串解析完，且符号栈为空时，则计算完成
StringBuffer tempNum = new StringBuffer();// 用来临时存放数字字符串(当为多位数时)
StringBuffer string = new StringBuffer().append(str);// 用来保存，提高效率

while (string.length() != 0) {
temp = string.substring(0, 1);
string.delete(0, 1);
// 判断temp，当temp为操作符时
if (!isNum(temp)) {
// 1.此时的tempNum内即为需要操作的数，取出数，压栈，并且清空tempNum
if (!"".equals(tempNum.toString())) {
// 当表达式的第一个符号为括号
int num = Integer.parseInt(tempNum.toString());
numStack.push(num);
tempNum.delete(0, tempNum.length());
}
// 用当前取得的运算符与栈顶运算符比较优先级：若高于，则因为会先运算，放入栈顶；若等于，因为出现在后面，所以会后计算，所以栈顶元素出栈，取出操作数运算；
// 若小于，则同理，取出栈顶元素运算，将结果入操作数栈。

// 判断当前运算符与栈顶元素优先级，取出元素，进行计算(因为优先级可能小于栈顶元素，还小于第二个元素等等，需要用循环判断)
while (!compare(temp.charAt(0)) && (!priStack.empty())) {
int a = (int) numStack.pop();// 第二个运算数
int b = (int) numStack.pop();// 第一个运算数
char ope = priStack.pop();
int result = 0;// 运算结果
switch (ope) {
// 如果是加号或者减号，则
case ‘+‘:
result = b + a;
// 将操作结果放入操作数栈
numStack.push(result);
break;
case ‘-‘:
result = b - a;
// 将操作结果放入操作数栈
numStack.push(result);
break;
case ‘*‘:
result = b * a;
// 将操作结果放入操作数栈
numStack.push(result);
break;
case ‘/‘:
result = b / a;// 将操作结果放入操作数栈
numStack.push(result);
break;
}

}
// 判断当前运算符与栈顶元素优先级， 如果高，或者低于平，计算完后，将当前操作符号，放入操作符栈
if (temp.charAt(0) != ‘#‘) {
priStack.push(new Character(temp.charAt(0)));
if (temp.charAt(0) == ‘)‘) {// 当栈顶为‘(‘，而当前元素为‘)‘时，则是括号内以算完，去掉括号
priStack.pop();
priStack.pop();
}
}
} else
// 当为非操作符时（数字）
tempNum = tempNum.append(temp);// 将读到的这一位数接到以读出的数后(当不是个位数的时候)
}
return numStack.pop();
}

/**
* 判断传入的字符是不是0-9的数字
*
* @param str
* 传入的字符串
* @return
*/
private boolean isNum(String temp) {
return temp.matches("[0-9]");
}

/**
* 比较当前操作符与栈顶元素操作符优先级，如果比栈顶元素优先级高，则返回true，否则返回false
*
* @param str 需要进行比较的字符
* @return 比较结果 true代表比栈顶元素优先级高，false代表比栈顶元素优先级低
*/
private boolean compare(char str) {
if (priStack.empty()) {
// 当为空时，显然 当前优先级最低，返回高
return true;
}
char last = (char) priStack.lastElement();
// 如果栈顶为‘(‘显然，优先级最低，‘)‘不可能为栈顶。
if (last == ‘(‘) {
return true;
}
switch (str) {
case ‘#‘:
return false;// 结束符
case ‘(‘:
// ‘(‘优先级最高,显然返回true
return true;
case ‘)‘:
// ‘)‘优先级最低，
return false;
case ‘*‘: {
// ‘*/‘优先级只比‘+-‘高
if (last == ‘+‘ || last == ‘-‘)
return true;
else
return false;
}
case ‘/‘: {
if (last == ‘+‘ || last == ‘-‘)
return true;
else
return false;
}
// ‘+-‘为最低，一直返回false
case ‘+‘:
return false;
case ‘-‘:
return false;
}
return true;
}

public static void main(String args[]) {
Operate operate = new Operate();

Scanner in = new Scanner(System.in);
for(int i=0;i<10;i++){//题目数量
int index = (int)(Math.random()*2);
String str = null;
if(index == 0) {
str = zhen();

System.out.println(str);

int t = operate.caculate(str.substring(0, str.length()-1));

list.add(str);

}
if(index == 1){
str = zhengshu();

int t = operate.caculate(str.substring(0, str.length()-1));

list.add(str);
}
}

int t = 0;//正确数量
int f =0;//错误数量
for(int j =0;j<num;j++){
if(in.next()=="done")
break;
if(list.get(j)==in.next()){
t++;
}
else
f++;
}
System.out.println("正确题目数为：" + t);
System.out.println("错误题目数为：" + f);

}

}
}

 

答題人：杨宇杰