java 计算器算法_计算器算法

计算器算法

计算器算法是一个相对有趣的算法，这篇文章会教会大家带括号优先级的计算器算法

生活中算术表达式是指中缀表达式例如：5 + 4 ÷ 2，计算机使用中缀表达式计算相对不方便，我们需要将中缀表达式转换成前缀或者后缀表达式，这里使用后缀表达式(逆波兰表达式)为例

逆波兰表达式

例如：3 4 + 5 × 6 -

计算方法：

从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算(次顶元素 op 栈顶元素)，并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果

举个栗子：从左至右扫描，将3和4压入堆栈

遇到+运算符，因此弹出4和3(4为栈顶元素，3为次顶元素，注意与前缀表达式做比较)，计算出3+4的值，得7，再将7入栈

将5入栈

接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈

将6入栈

最后是-运算符，计算出35-6的值，即29，由此得出最终结果

将中缀表达式转换为后缀表达式初始化两个栈：运算符栈s1和储存中间结果的栈s2；

从左至右扫描中缀表达式；

遇到操作数时，将其压s2；

遇到运算符时，比较其与s1栈顶运算符的优先级：如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；

否则，若优先级比栈顶运算符的高，也将运算符压入s1(注意转换为前缀表达式时是优先级较高或相同，而这里则不包括相同的情况)；

否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较；

遇到括号时：如果是左括号“(”，则直接压入s1；

如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃；

重复步骤2至5，直到表达式的最右边；

将s1中剩余的运算符依次弹出并压入s2；

依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式(转换为前缀表达式时不用逆序)

例如，将中缀表达式“1+((2+3)×4)-5”转换为后缀表达式的过程如下：

因此结果为：1 2 3 + 4 × + 5 -

数据结构

下面我们开始构建计算器要用到的数据结构，以java为例，例子中数据结构比较复杂

/*** 操作符号枚举** @author Julius**/

enum OperationValue {

plus("+"), minus("-"), multiply("*"), divide("/");

String value;

OperationValue(String value) {

this.value = value;

}

@Override

public String toString() {

return this.value;

}

}

/*** 算术操作符类** @author Julius**/

static class Operation {

/*** 操作符*/

OperationValue value;

/*** 优先度*/

int priority;

final static int low = 1;

final static int high = 2;

public Operation(OperationValue value, int priority) {

this.value = value;

this.priority = priority;

}

@Override

public String toString() {

return this.value.toString();

}

}

static Operation plus, minus, multiply, divide, left, right;

static {

plus = new Operation(OperationValue.plus, Operation.low);

minus = new Operation(OperationValue.minus, Operation.low);

multiply = new Operation(OperationValue.multiply, Operation.high);

divide = new Operation(OperationValue.divide, Operation.high);

}

获取表达式包含的操作数与操作符

中缀表达式 1 + 2 + 3，我们需要提取其中的操作数与操作符，把提取到的数据保存到集合中，以java为例：

/*** 算术表达式转换成操作模型 Double类表示操作数, Operation类代表操作符** @param s* 算术表达式* @return*/

public static List getOperand(String s) {

List list = new ArrayList<>();

int begin = 0;

for (int i = 0; i < s.length(); i++) {

char c = s.charAt(i);

if (String.valueOf(c).matches("\\+|-|\\*|/|\\(|\\)")) {

String sub = s.substring(begin, i);

if (!sub.equals("")) {

list.add(Double.parseDouble(sub));

}

list.add(parseOperation(String.valueOf(c)));

begin = i + 1;

}

}

String sub = s.substring(begin);

if (!sub.equals("")) {

list.add(Double.parseDouble(sub));

}

return list;

}

/*** 字符串转换成操作符类** @param c* @return*/

public static Operation parseOperation(String c) {

if (c.equals(OperationValue.plus.toString())) {

return plus;

}

if (c.equals(OperationValue.minus.toString())) {

return minus;

}

if (c.equals(OperationValue.multiply.toString())) {

return multiply;

}

if (c.equals(OperationValue.divide.toString())) {

return divide;

}

return null;

}

中缀表达式转换成后缀(逆波兰表达式)表达式

到这里才是计算器算法中的重点之一，为了方便计算机运算，我们需要进行表达式的转换。根据本文标题三中的流程描述给出代码，以java为例子：

/*** 将算术表达式转化逆波兰表达式** @param s* 算术表达式* @return*/

public static Stack parse2ReversePolishNotation(String s) {

s = s.replace(" ", "");

Stack operationStack = new Stack<>();

Stack expressionStack = new Stack<>();

List operandList = getOperand(s);

for (Object o : operandList) {

if (o instanceof Double) {

expressionStack.push((Double) o);

} else if (o instanceof String) {

String si = (String) o;

if (si.equals("(")) {

operationStack.push(si);

} else if (si.equals(")")) {

while (!operationStack.peek().equals("(")) {

expressionStack.push(parseOperation(operationStack.pop()));

}

operationStack.pop();

}

} else if (o instanceof Operation) {

Operation operation = (Operation) o;

while (!operationStack.isEmpty() && !operationStack.peek().equals("(")

&& operation.priority <= parseOperation(operationStack.peek()).priority) {

expressionStack.push(parseOperation(operationStack.pop()));

}

operationStack.push(operation.value.toString());

}

}

while (!operationStack.isEmpty()) {

expressionStack.push(parseOperation(operationStack.pop()));

}

return expressionStack;

}

计算后缀表达式

根据本文标题二中信息描述转化为代码，以java为例：

/*** 计算逆波兰表达式** @param expressionStack* 逆波兰表达式* @return*/

public static double calculateReversePolishNotation(Stack expressionStack) {

Stack calculateStack = new Stack<>();

for (int i = 0; i < expressionStack.size(); i++) {

Object o = expressionStack.get(i);

if (o instanceof Double) {

calculateStack.push(o);

} else if (o instanceof Operation) {

double number1 = (Double) calculateStack.pop();

double number2 = (Double) calculateStack.pop();

calculateStack.push(calculate(number1, number2, (Operation) o));

}

}

return (Double) calculateStack.pop();

}

/*** 两个数运算** @param number1* @param number2* @param operation* @return*/

public static Double calculate(double number1, double number2, Operation operation) {

if (operation.value == OperationValue.plus) {

return number2 + number1;

}

if (operation.value == OperationValue.minus) {

return number2 - number1;

}

if (operation.value == OperationValue.multiply) {

return number2 * number1;

}

if (operation.value == OperationValue.divide) {

return number2 / number1;

}

return null;

}

/*** 计算表达式** @param s* @return*/

public static double calculate(String s) {

return calculateReversePolishNotation(parse2ReversePolishNotation(s));

}

到此整个计算器算法结束了，在主函数中调用calculate("...")计算表达式结果，例如：calculate("9 + 8 * 6.2 + (8 / 5.3 + (2 + 2.5))

结尾

本文介绍了逆波兰表达式，逆波兰表达式的计算方法以及转换方法，并给出逆波兰表达式计算数学表达式的方法，给与大家参考