第一章作业题

题目大意

package com.mindto.other;

import java.util.Stack;

/**
* 解题思路：
* 1、获取字符串，得到不含有空格的表达式串，形如：1+2/3，记为 destStr
* 2、判断是否符合计算要求，符合则进行下一步，否则，输出错误，退出。
* 3、执行如下算法：
*  a,定义存储操作数的栈OVS，定义存储操作符的栈OPTR
*  b,自左向右扫描destStr，若是操作数，进栈OVS，若是操作符，则与OPTR栈顶的操作符比较：
*      。若当前操作符优先级大于OPTR栈顶操作符优先级，则进栈
*      。若当前操作符优先级小于或等于OPTR栈顶操作符优先级，则OPTR栈退栈一次，得到操作符x，OVS栈退栈2次，得到操作数a,b，进行x运算，结果入栈OVS
*  c,若是(，则获取第一个和它匹配的)中间的字符串进行扫描操作
* 4、对计算结果进行格式化，输出
* */
public class XTZX1 {
/*定义栈、表达式字符串及其他实例变量*/
private char[] destStr;
/*构造函数，进行初始化*/
XTZX1(String[] srcStr) {
//获取表达式字符串
StringBuffer buffer = new StringBuffer();
for (String str : srcStr) {
buffer.append(str);
}
destStr = buffer.toString().replace(" ", "").toCharArray();
//System.out.println("destStr`length = " + new String(destStr).length());
}
/*
* 解决问题
* target 当前处理的位置
* end 处理结束位置
* */
public void solve(int target, int end) {
//printChar();
//符合计算要求才进行计算
if (isLegal()) {
double r = calculate(target, end);
outputWithFormat(r);
}
}
private void outputWithFormat(double value) {
//System.out.println(value);
String temp = String.valueOf(value);
int dotIndex = temp.indexOf(".");
//System.out.println("indexof. = " + temp.indexOf("."));
int l = temp.substring(dotIndex).length();
if (l == 2) {//形如4.0这样的结果
System.out.println(temp.substring(0, temp.length() - 2));
}
if (l > 2 && l <=11) {
System.out.println(temp);
}
if (l > 11) {
//用来计算输出的数组
char[] result = temp.substring(0, dotIndex + 11).toCharArray();
//System.out.println(result);
char c = temp.charAt(dotIndex + 11);
//System.out.println("charAt(dotIndex + 11) = " + c);
if (c >= '5') {//四舍五入
int len = result.length;
//System.out.println("result.length = " + len);
int up = 1;
for (int i = len - 1; i >= 0 && up == 1; i --) {
if (result[i] == '.') {
continue;
}
int t = result[i] - '0' + up;
if (t >= 10) {
result[i] = (char) ('0' + (t % 10));
}else {
up = 0;
result[i] = (char) ('0' + t);
}
}
}
double before = Double.parseDouble(new String(result));//转换成数字
String bStr = String.valueOf(before);
if (bStr.substring(bStr.indexOf(".")).length() == 2) {
System.out.println(bStr.substring(0, bStr.length() - 2));
}else {
System.out.println(result);
}
}

}
/*
* 判断该表达式是否合法
* */
private boolean isLegal() {
String targetStr = new String(getDestStr());
//判断是否由数字，运算符以及 . ()组成
if (!targetStr.matches("^[0-9\\.\\(\\)\\+\\-\\*/]*$")) {
System.out.println("INPUT ERROR");
return false;
}
if (!isFromatOK()) {
System.out.println("FORMAT ERROR");
return false;
}
return true;
}
private boolean isFromatOK() {
int ovsNum = 0;
int optrNum = 0;
int left = 0;
int right = 0;
int begin = 0;
int end = getDestStr().length;
while (begin < end) {
char c = getDestStr()[begin];
if (c >= '0' && c <= '9') {
StringBuffer buffer = new StringBuffer();
while (begin < end) {
buffer.append(c);
begin ++;
if (begin >= end) {
break;
}
c = getDestStr()[begin];
if (c == '+' || c == '-' || c == '*' || c == '/' || c == '^') {
break;
}
}
ovsNum ++;
}
if (c == '+' || c == '-' || c == '*' || c == '/') {
optrNum ++;
}
if (c == '(') {
left ++;
}
if (c == ')') {
right ++;
}
begin ++;
}
if (ovsNum - 1 == optrNum && left == right) {
return true;
}
return false;
}
/*
* 计算从begin到end表达式的值
* */
private double calculate(int begin, int end) {
Stack<Double> ovs = new Stack<>();
Stack<Character> optr = new Stack<>();
//从begin开始扫描到end
while (begin < end) {
char c = getDestStr()[begin];
//是操作数（可能是小数）,则取出操作数，入栈
if (c <= '9' && c >= '0') {
StringBuffer buffer = new StringBuffer();
while (begin < end) {
//System.out.print(c);
buffer.append(c);
begin ++;
if (begin >= end) {
break;
}
c = getDestStr()[begin];
if (c == '+' || c == '-' || c == '*' || c == '/' || c == '^') {
break;
}
}
//入栈
ovs.push(Double.parseDouble(buffer.toString()));
}
//是操作符
if (c == '+' || c == '-' || c == '*' || c == '/' || c == '^') {
//操作符栈是否为空,空则直接入栈，否则进行比较
if (optr.isEmpty()) {
optr.push(c);
}else {
char topChar = optr.peek();
//当前运算符优先级大于栈顶运算符优先级，直接入栈
if (getLeave(c) > getLeave(topChar)) {
optr.push(c);
}else {
topChar = optr.pop();//运算符出栈
double a = ovs.pop();//运算数出栈
double b = ovs.pop();
ovs.push(calculateWithOption(topChar, b, a));
optr.push(c);
}
}
begin ++;
}
//左括号
if (c == '(') {
int subEnd = end;
while (c != ')') {
subEnd --;
c = getDestStr()[subEnd];
}//退出时subEnd是')'的下标值
double subResult = calculate(++begin, subEnd);
//计算结构入栈
ovs.push(subResult);
subEnd ++;
begin = subEnd;
}
}
while (!optr.isEmpty()) {
double a = ovs.pop();
double b = ovs.pop();
ovs.push(calculateWithOption(optr.pop(), b, a));
}
return ovs.peek();
}
/*
* 获取操作符优先级
* */
private int getLeave(char c) {
int leave = 0;
switch (c) {
case '+':
case '-':
leave = 1;
break;
case '*':
case '/':
leave = 2;
break;
case '^':
leave = 3;
break;
}
return leave;
}
/*
* 根据操作符进行运算
* */
private double calculateWithOption(char c, double a, double b) {
double result = 0;
switch (c) {
case '+':
result = a + b;
break;
case '-':
result = a - b;
break;
case '*':
result = a * b;
break;
case '/':
if (b == 0) {
System.out.println("VALUE ERROR");
System.exit(1);
}
result = a / b;
break;
case '^':
result = Math.pow(a, b);
break;
}
return result;
}
public char[] getDestStr() {
return destStr;
}
public void setDestStr(char[] destStr) {
this.destStr = destStr;
}
public void printChar() {
for (char c : getDestStr()) {
System.out.print(c);
}
System.out.println();
}
public static void main(String[] args) {
XTZX1 xtzx1 = new XTZX1(args);
xtzx1.solve(0, xtzx1.getDestStr().length);
}
}