一、栈
1.1 概述
- 栈是一个先入后出（FILO-First In Last Out）的有序列表。
- 栈（Stack）是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶（top），另一端为固定的一端，称为栈底（bottom）。
- 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
- 示意图：
1.2 应用场景
- 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
- 处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
- 表达式的转换中缀表达式转后缀表达式与求值（实际解决问题）。
- 二叉树的遍历。
- 图形的深度优先（depth 一 first）搜索法。
1.3 数组模拟栈
由于栈是一种有序列表，则我们可以使用数组的结构来储存栈的数据内容，下面我们就用数组模拟栈的出栈，入栈等操作。
- 思路分析：
- 定义一个
top来表示栈顶，初始化为 -1。 - 入栈操作：当有数据加入到栈的时候，栈顶移动（
top++;） 并赋值 （stack[top]=data;）。 - 出栈操作：得到当前栈顶值（
value=stack[top]），栈顶回退（top--），返回值（return value）。
- 定义一个
- 代码示例：
public class ArrayStackDemo {
public static void main(String[] args) {
// 栈的大小为4。
ArrayStack stack = new ArrayStack(4);
String cmd = "";
//控制是否退出菜单。
boolean isLoop = true;
Scanner scanner = new Scanner(System.in);
while (isLoop) {
System.out.println("show: 表示显示栈");
System.out.println("exit: 退出程序");
System.out.println("push: 表示添加数据到栈(入栈)");
System.out.println("pop: 表示从栈取出数据(出栈)");
System.out.println("请输入你的选择");
cmd = scanner.next();
switch (cmd) {
case "show":
stack.show();
break;
case "push":
System.out.println("请输入一个数");
int value = scanner.nextInt();
stack.push(value);
break;
case "pop":
try {
int res = stack.pop();
System.out.printf("出栈的数据是 %d\n", res);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case "exit":
scanner.close();
isLoop = false;
break;
default:
break;
}
}
System.out.println("程序退出~~~");
}
}
/**
* 数组模拟栈。
*/
class ArrayStack {
private final int maxSize;
private int[] stack;
private int top;
/**
* 构造器。
*
* @param size 大小
*/
public ArrayStack(int size) {
this.maxSize = size;
stack = new int[this.maxSize];
top = -1;
}
/**
* 栈是否为空。
*
* @return boolean
*/
public boolean isEmpty() {
return this.top == -1;
}
/**
* 栈中元素是否已满。
*
* @return boolean
*/
public boolean isFull() {
return this.top == maxSize - 1;
}
/**
* 入栈。
*
* @param val 整数值。
*/
public void push(int val) {
if (isFull()) {
System.out.println("栈满，无法继续添加元素。");
return;
}
top++;
stack[top] = val;
}
/**
* 出栈。
*
* @return int
*/
public int pop() {
if (isEmpty()) {
throw new NullPointerException("栈空，无法获取元素。");
}
int value = stack[top];
top--;
return value;
}
/**
* 显示栈中元素。
*/
public void show() {
if (isEmpty()) {
System.out.println("当前栈中元素为空。");
return;
}
// 从栈顶开始遍历。
for (int i = this.top; i >= 0; i--) {
System.out.printf("stack[%d]=%d\n", i, stack[i]);
}
}
}
- 测试结果 ：
二、栈实现综合计算器
需求：通过栈的数据结构完成一个计算器，用于计算一个表达式的值（例如：“7*2*2-5+1-5+3-4” = 18）。
- 思路分析：
- 代码示例：
public class Calculator {
public static void main(String[] args) {
// 表达式。
String expression = "7*2*2-5+1-5+3-4";
// 表达式 7*2*2-5+1-5+3-4 = 18
// 创建数组栈（数栈及符号栈）。
ArrayStack2 numStack = new ArrayStack2(10);
ArrayStack2 operatorStack = new ArrayStack2(10);
// 定义存储数字、运算符号、扫描索引、运算结果的变量。
int num1 = 0;
int num2 = 0;
int operator = 0;
int index = 0;
int result = 0;
// 临时变量，用于记录当前扫描的字符、多位数。
char ch;
String keepNum = "";
do {
// 获取字符串的每一位。
ch = expression.substring(index, index + 1).charAt(0);
// 若取出的是符号。
if (operatorStack.isOperator(ch)) {
// 符号栈中不为空。
if (!operatorStack.isEmpty()) {
// 运算符号优先级判断。
int curPriority = operatorStack.priority(ch);
int top = operatorStack.peek();
int topPriority = operatorStack.priority(top);
if (curPriority <= topPriority) {
// 如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符, 就需要从数栈中 pop 出两个数。
// 在从符号栈中 pop 出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈。
num1 = numStack.pop();
num2 = numStack.pop();
operator = operatorStack.pop();
result = numStack.calc(num1, num2, operator);
// 运算结果入数栈。
numStack.push(result);
// 当前运算符入符号栈。
operatorStack.push(ch);
} else {
// 如果当前的操作符的优先级大于栈中的操作符，则入符号栈。
operatorStack.push(ch);
}
} else {
// 为空，就直接入符号栈。
operatorStack.push(ch);
}
} else {
// 1. 当处理多位数时，不能发现是一个数就立即入栈，因为有可能是多位数。
// 2. 在处理数，需要向 expression 的表达式的 index 后再看一位,如果是数就进行扫描，如果是符号才入栈。
// 3. 因此我们需要定义一个变量字符串，用于拼接。
keepNum += ch;
// 如果 ch 已经是 expression 的最后一位，就直接入栈。
if (index == expression.length() - 1) {
int num = Integer.parseInt(keepNum);
numStack.push(num);
} else {
// 判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈。
// 注意：是看后一位，不是index++ 。
char c = expression.substring(index + 1, index + 2).charAt(0);
if (operatorStack.isOperator(c)) {
int num = Integer.parseInt(keepNum);
numStack.push(num);
// 注意：完成之后，需要清空变量。
keepNum = "";
}
}
}
//让 index + 1, 并判断是否扫描到 expression 最后。
index++;
} while (index < expression.length());
// 扫描结束，则顺序取出符号和数字进行计算。
while (!operatorStack.isEmpty()) {
num1 = numStack.pop();
num2 = numStack.pop();
operator = operatorStack.pop();
result = numStack.calc(num1, num2, operator);
numStack.push(result);
}
// 将数栈的最后数，pop 出，就是最终计算结果。
int res2 = numStack.pop();
System.out.printf("表达式 %s = %d", expression, res2);
}
}
class ArrayStack2 {
private int maxSize;
private int[] stack;
private int top;
/**
* 构造器。
*
* @param size 大小
*/
public ArrayStack2(int size) {
this.maxSize = size;
stack = new int[this.maxSize];
top = -1;
}
/**
* 栈是否为空。
*
* @return boolean
*/
public boolean isEmpty() {
return this.top == -1;
}
/**
* 栈中元素是否已满。
*
* @return boolean
*/
public boolean isFull() {
return this.top == maxSize - 1;
}
/**
* 入栈。
*
* @param val 整数值。
*/
public void push(int val) {
if (isFull()) {
System.out.println("栈满，无法继续添加元素。");
return;
}
top++;
stack[top] = val;
}
/**
* 出栈。
*
* @return int
*/
public int pop() {
if (isEmpty()) {
throw new NullPointerException("栈空，无法获取元素。");
}
int value = stack[top];
top--;
return value;
}
/**
* 显示栈中元素。
*/
public void show() {
if (isEmpty()) {
System.out.println("当前栈中元素为空。");
return;
}
for (int i = this.top; i >= 0; i--) {
System.out.printf("stack[%d]=%d\n", i, stack[i]);
}
}
/**
* 否为运算符号。
*
* @param ch ch
* @return boolean
*/
public boolean isOperator(char ch) {
return ('+' == ch) || ('-' == ch) || ('*' == ch) || ('/' == ch);
}
/**
* 运算优先级。
*
* @param ch ch
* @return boolean
*/
public int priority(int ch) {
if ('*' == ch || '/' == ch) {
return 1;
} else if ('+' == ch || '-' == ch) {
return 0;
} else {
return -1;
}
}
/**
* 查看栈顶值。
* 注意：这里只是查看而非将值出栈。
*
* @return int
*/
public int peek() {
return this.stack[top];
}
/**
* 计算。
*
* @param num1 num1
* @param num2 num2
* @param operator 操作符
* @return int
*/
public int calc(int num1, int num2, int operator) {
int res = 0;
// 注意计算[减法]和[除法]的数顺序。
switch (operator) {
case '+':
res = num1 + num2;
break;
case '-':
res = num2 - num1;
break;
case '*':
res = num1 * num2;
break;
case '/':
res = num2 / num1;
break;
default:
break;
}
return res;
}
}
三、逆波兰表达式
需求：输入一个逆波兰表达式（后缀表达式），使用栈（Stack）, 计算其结果。
3.1 表达式分类
示例表达式：（3+4）* 5-6
| 表达式名称 | 示例 | 定义 | 运算过程 |
|---|---|---|---|
| 前缀表达式 | - * + 3 4 5 6 | 前缀表达式又称波兰式，在该表达式中，运算符位于操作数之前。 | 从右向左扫描表达式。遇到数字，将数字压入数字栈；遇到运算符，弹出两个数字，用运算符进行计算（栈顶与次顶），将计算的结果再次压入数字栈。重复操作，直到扫描到表达式的最左端，此时最后运算的值，即为结果。 |
| 中缀表达式 | （3+4）* 5-6 | 中缀表达式就是我们平时最熟悉的运算表达式。虽然我们很好解读中缀表达式，但是对计算机来说却不好操作，需要在每次判断是否为操作符、判断优先级等等。因此，我们常常将中缀表达式转化成其他表达式来进行操作。 | 该篇第二节，<二、栈实现综合计算器>就是解析的中缀表达式。 |
| 后缀表达式 | 3 4 + 5 * 6 - | 后缀表达式又称逆波兰表达式。运算符位于操作数的后面。 | 从左至右扫描表达式，遇到数字时，将数字压入数字栈。遇到符号时，弹出两个栈顶元素，用运算符进行相应的运算，并将结果入栈。重复操作，直到扫描到表达式的最右端，最后计算的值即为表达式的结果。 |
3.2 需求实现
- 代码示例：
public class ReversePolishNotation {
public static void main(String[] args) {
// 示例：(30+4)×5-6 => 30 4 + 5 × 6 - => 164
String suffixExpression = "30 4 + 5 * 6 -";
List<String> list = toList(suffixExpression);
Integer res = calc(list);
System.out.printf("后缀表达式\"%s\"的计算结果=[%d]", suffixExpression, res);
// 后缀表达式"30 4 + 5 * 6 -"的计算结果=[164]
System.out.println();
String suffixExpression1 = "4 5 * 8 - 60 + 8 2 / +";
List<String> list1 = toList(suffixExpression1);
Integer res1 = calc(list1);
System.out.printf("后缀表达式\"%s\"的计算结果=[%d]", suffixExpression1, res1);
// 后缀表达式"4 5 * 8 - 60 + 8 2 / +"的计算结果=[76]
}
/**
* 将后缀表达式中的元素放入列表。
*
* @param expression 表达式
* @return {@link List}<{@link String}>
*/
public static List<String> toList(String expression) {
String[] items = expression.split(" ");
return new ArrayList<>(Arrays.asList(items));
}
/**
* 计算操作。
*
* @param list 列表
* @return {@link Integer}
*/
public static Integer calc(List<String> list) {
Stack<Integer> stack = new Stack<>();
list.forEach(item -> {
// 判断是否为数字。
if (item.matches("\\d+")) {
int num = Integer.parseInt(item);
stack.push(num);
} else {
// 如果是符号则进行计算。
Integer num1 = stack.pop();
Integer num2 = stack.pop();
int result = 0;
// 注意减法和除法的顺序。
switch (item) {
case "+":
result = num1 + num2;
break;
case "-":
result = num2 - num1;
break;
case "*":
case "x":
result = num1 * num2;
break;
case "/":
result = num2 / num1;
break;
default:
throw new RuntimeException("不支持的运算符号。");
}
// 将计算结果入栈。
stack.push(result);
}
});
// 循环结束后，在最后的就是最终的计算结果。
return stack.pop();
}
}
3.3 中缀转后缀表达式
可以看到，后缀表达式适合计算机进行运算，但是人却不太容易写出来，尤其是表达式很长的情况下。因此在开发中，我们需要将中缀表达式转成后缀表达式（具体思路如下）。
- 初始化两个栈：运算符栈s1 和 储存中间结果的栈s2；
- 从左至右扫描中缀表达式；
- 遇到操作数时，将其压 s2；
- 遇到运算符时，比较其与 s1 栈顶运算符的优先级：
- 如果 s1 为空，或栈顶运算符为左括号
“(”，则直接将此运算符入栈； - 否则，若优先级比栈顶运算符的高，也将运算符压入 s1；
- 否则，将 s1 栈顶的运算符弹出并压入到 s2 中，再次与 s1 中新的栈顶运算符相比较；
- 如果 s1 为空，或栈顶运算符为左括号
- 遇到括号时：
- 如果是左括号
“(”，则直接压入 s1； - 如果是右括号
“)”，则依次弹出 s1 栈顶的运算符，并压入 s2，直到遇到左括号为止，此时将这一对括号丢弃； - 重复上述对括号操作的步骤，直到表达式的最右边。
- 将 s1 中剩余的运算符依次弹出并压入 s2；
- 依次弹出 s2 中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式。
- 如果是左括号
此处以中缀表达式 “1+((2+3)×4)-5” 转后缀表达式 “1 2 3 + 4 × + 5 –” 作为过程说明（具体过程如下）：
| 当前元素 | 储存中间结果的栈s2（栈顶至栈底） | 运算符栈s1（栈顶至栈底） | 说明 |
|---|---|---|---|
| 1 | 1 | 空 | 数字，直接入栈 |
| + | 1 | + | s1为空，符号直接入栈 |
| ( | 1 | + ( | 左括号，直接入栈 |
| ( | 1 | + ( ( | 同上 |
| 2 | 1 2 | + ( ( | 数字，直接入栈 |
| + | 1 2 | + ( ( + | 当前s1栈顶为左括号，运算符直接入栈 |
| 3 | 1 2 3 | + ( ( + | 数字，直接入栈 |
| ) | 1 2 3 + | + ( | 弹出运算符直至遇到左括号 |
| x | 1 2 3 + | + ( x | 当前s1栈顶为左括号，运算符直接入栈 |
| 4 | 1 2 3 + 4 | + ( x | 数字，直接入栈 |
| ) | 1 2 3 + 4 x | + | 弹出运算符直至遇到左括号 |
| - | 1 2 3 + 4 x + | - | 与 + 优先级相同，弹出 +，再压入 - |
| 5 | 1 2 3 + 4 x + 5 | - | 数字，直接入栈 |
| 到达最右端 | 1 2 3 + 4 x + 5 - | 空栈 | s1剩余运算符压入s2 |
- 代码示例：
public class ConvertExpressionDemo {
public static void main(String[] args) {
// 1.中缀表达式。
String expression = "1+((2+3)*4)-5";
// 2.中缀表达式字符串转化为中缀元素列表。
List<String> infixExpressionList = toInfixExpressionList(expression);
System.out.println("中缀表达式对应的List=" + infixExpressionList);
// 中缀表达式对应的List=[1, +, (, (, 2, +, 3, ), *, 4, ), -, 5]
// 3.中缀元素列表转换为后缀元素列表。
List<String> suffixExpressionList = parseSuffixExpressionList(infixExpressionList);
System.out.println("后缀表达式对应的List=" + suffixExpressionList);
// 后缀表达式对应的List=[1, 2, 3, +, 4, *, +, 5, -]
System.out.printf("表达式 \"%s\" 计算得到结果=[%d]", expression, doCalc(suffixExpressionList));
// 表达式 "1+((2+3)*4)-5" 计算得到结果=[16]
}
/**
* 中缀表达式字符串转换为列表。
*
* @param infixExpression 中缀表达式
* @return {@link List}<{@link String}>
*/
public static List<String> toInfixExpressionList(String infixExpression) {
List<String> list = new ArrayList<>();
int index = 0;
char cur;
StringBuilder str;
while (index < infixExpression.length()) {
// 根据ascii码值判断当前字符是否为数字。
if ((cur = infixExpression.charAt(index)) < 48 || (cur = infixExpression.charAt(index)) > 57) {
// 非数字直接添加到列表。
list.add(cur + "");
index++;
} else {
str = new StringBuilder();
while (index < infixExpression.length()
&& (cur = infixExpression.charAt(index)) >= 48
&& (cur = infixExpression.charAt(index)) <= 57) {
// 多位数拼接。
str.append(cur);
index++;
}
list.add(str.toString());
}
}
return list;
}
/**
* 通过[中缀表达式列表]解析得到[后缀表达式列表]。
*
* @param infixExpressionList 中缀表达式列表
* @return {@link List}<{@link String}>
*/
public static List<String> parseSuffixExpressionList(List<String> infixExpressionList) {
// 符号栈。
Stack<String> s1 = new Stack<>();
// 储存中间结果。
// 备注：举例的过程中是使用栈，但是由于没有pop操作，后面我们还需要逆序输出，因此此处使用列表来替代栈。
List<String> l2 = new ArrayList<>();
for (String item : infixExpressionList) {
//如果是一个数，加入l2。
if (item.matches("\\d+")) {
l2.add(item);
} else if ("(".equals(item)) {
s1.push(item);
} else if (")".equals(item)) {
// 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入l2，直到遇到左括号为止，此时将这一对括号丢弃。
while (!"(".equals(s1.peek())) {
l2.add(s1.pop());
}
// 弹出 s1栈， 消除小括号。
s1.pop();
} else {
// 当item的优先级小于等于s1栈顶运算符, 将s1栈顶的运算符弹出并加入到l2中，再次与s1中新的栈顶运算符相比较。
while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
l2.add(s1.pop());
}
// 还需要将item压入栈。
s1.push(item);
}
}
//将s1中剩余的运算符依次弹出并加入l2。
while (s1.size() != 0) {
l2.add(s1.pop());
}
//注意因为是存放到List, 因此按顺序输出就是对应的后缀表达式对应的List
return l2;
}
/**
* 执行计算。
*
* @param suffixExpressionList 后缀表达式元素列表。
* @return int
*/
public static int doCalc(List<String> suffixExpressionList) {
Stack<String> stack = new Stack<>();
for (String item : suffixExpressionList) {
// 这里使用正则表达式来取出数。
// 匹配的是多位数。
if (item.matches("\\d+")) {
stack.push(item);
} else {
// pop出两个数，并运算， 再入栈
int num2 = Integer.parseInt(stack.pop());
int num1 = Integer.parseInt(stack.pop());
int res = 0;
switch (item) {
case "+":
res = num1 + num2;
break;
case "-":
res = num1 - num2;
break;
case "*":
res = num1 * num2;
break;
case "/":
res = num1 / num2;
break;
default:
throw new RuntimeException("运算符有误");
}
//把 res 入栈。
stack.push("" + res);
}
}
//最后留在stack中的数据是运算结果。
return Integer.parseInt(stack.pop());
}
}
class Operation {
private final static int ADD = 1;
private final static int SUB = 1;
private final static int MUL = 2;
private final static int DIV = 2;
/**
* 返回对应的优先级数字。
*
* @param operation 运算符
* @return int
*/
public static int getValue(String operation) {
int result = 0;
switch (operation) {
case "+":
result = ADD;
break;
case "-":
result = SUB;
break;
case "*":
case "x":
result = MUL;
break;
case "/":
result = DIV;
break;
default:
break;
}
return result;
}
}
3.4 完整逆波兰计算器
完整版的逆波兰计算器，功能包括支持
+-*/()；多位数，支持小数；兼容处理, 过滤任何空白字符，包括空格、制表符、换页符。
- 代码示例：
public class ReversePolishMultiCalc {
public static void main(String[] args) {
//String math = "9+(3-1)*3+10/2";
String math = "12.8 + (2 - 3.55)*4+10/5.0";
try {
doCalc(doMatch(math));
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 匹配 + - * / ( ) 运算符。
*/
static final String SYMBOL = "\\+|-|\\*|/|\\(|\\)";
static final String LEFT = "(";
static final String RIGHT = ")";
static final String ADD = "+";
static final String MINUS = "-";
static final String TIMES = "*";
static final String DIVISION = "/";
/**
* 加減 + -
*/
static final int LEVEL_01 = 1;
/**
* 乘除 * /
*/
static final int LEVEL_02 = 2;
/**
* 括号
*/
static final int LEVEL_HIGH = Integer.MAX_VALUE;
static Stack<String> stack = new Stack<>();
static List<String> data = Collections.synchronizedList(new ArrayList<String>());
/**
* 去除所有空白符。
*
* @param s
* @return
*/
public static String replaceAllBlank(String s) {
// \\s+ 匹配任何空白字符，包括空格、制表符、换页符等等, 等价于[ \f\n\r\t\v]
return s.replaceAll("\\s+", "");
}
/**
* 判断是不是数字 int double long float。
*
* @param s
* @return
*/
public static boolean isNumber(String s) {
Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");
return pattern.matcher(s).matches();
}
/**
* 判断是不是运算符。
*
* @param s
* @return
*/
public static boolean isSymbol(String s) {
return s.matches(SYMBOL);
}
/**
* 匹配运算等级。
*
* @param s
* @return
*/
public static int calcLevel(String s) {
if ("+".equals(s) || "-".equals(s)) {
return LEVEL_01;
} else if ("*".equals(s) || "/".equals(s)) {
return LEVEL_02;
}
return LEVEL_HIGH;
}
/**
* 匹配。
*
* @param s
*/
public static List<String> doMatch(String s) {
if (s == null || "".equals(s.trim())) {
throw new RuntimeException("data is empty");
}
if (!isNumber(s.charAt(0) + "")) {
throw new RuntimeException("data illeagle,start not with a number");
}
s = replaceAllBlank(s);
String each;
int start = 0;
for (int i = 0; i < s.length(); i++) {
if (isSymbol(s.charAt(i) + "")) {
each = s.charAt(i) + "";
//栈为空，(操作符，或者 操作符优先级大于栈顶优先级 && 操作符优先级不是( )的优先级 及是 ) 不能直接入栈。
if (stack.isEmpty() || LEFT.equals(each)
|| ((calcLevel(each) > calcLevel(stack.peek())) && calcLevel(each) < LEVEL_HIGH)) {
stack.push(each);
} else if (!stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek())) {
//栈非空，操作符优先级小于等于栈顶优先级时出栈入列，直到栈为空，或者遇到了(，最后操作符入栈。
while (!stack.isEmpty() && calcLevel(each) <= calcLevel(stack.peek())) {
if (calcLevel(stack.peek()) == LEVEL_HIGH) {
break;
}
data.add(stack.pop());
}
stack.push(each);
} else if (RIGHT.equals(each)) {
// ) 操作符，依次出栈入列直到空栈或者遇到了第一个)操作符，此时)出栈。
while (!stack.isEmpty() && LEVEL_HIGH >= calcLevel(stack.peek())) {
if (LEVEL_HIGH == calcLevel(stack.peek())) {
stack.pop();
break;
}
data.add(stack.pop());
}
}
//前一个运算符的位置。
start = i;
} else if (i == s.length() - 1 || isSymbol(s.charAt(i + 1) + "")) {
each = start == 0 ? s.substring(start, i + 1) : s.substring(start + 1, i + 1);
if (isNumber(each)) {
data.add(each);
continue;
}
throw new RuntimeException("data not match number");
}
}
//如果栈里还有元素，此时元素需要依次出栈入列，可以想象栈里剩下栈顶为/，栈底为+，应该依次出栈入列，可以直接翻转整个stack 添加到队列。
Collections.reverse(stack);
data.addAll(new ArrayList<>(stack));
System.out.println(data);
return data;
}
/**
* 算出结果。
*
* @param list
* @return
*/
public static Double doCalc(List<String> list) {
Double d = 0d;
if (list == null || list.isEmpty()) {
return null;
}
if (list.size() == 1) {
System.out.println(list);
d = Double.valueOf(list.get(0));
return d;
}
ArrayList<String> list1 = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
list1.add(list.get(i));
if (isSymbol(list.get(i))) {
Double d1 = doTheMath(list.get(i - 2), list.get(i - 1), list.get(i));
list1.remove(i);
list1.remove(i - 1);
list1.set(i - 2, d1 + "");
list1.addAll(list.subList(i + 1, list.size()));
break;
}
}
doCalc(list1);
return d;
}
/**
* 运算。
*
* @param s1
* @param s2
* @param symbol
* @return
*/
public static Double doTheMath(String s1, String s2, String symbol) {
Double result;
switch (symbol) {
case ADD:
result = Double.parseDouble(s1) + Double.parseDouble(s2);
break;
case MINUS:
result = Double.parseDouble(s1) - Double.parseDouble(s2);
break;
case TIMES:
result = Double.parseDouble(s1) * Double.parseDouble(s2);
break;
case DIVISION:
result = Double.parseDouble(s1) / Double.parseDouble(s2);
break;
default:
result = null;
}
return result;
}
}
四、结束语
“-------怕什么真理无穷,进一寸有一寸的欢喜。”
微信公众号搜索：饺子泡牛奶。
扫一扫
16万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
