1. 栈的介绍
1.1 文字描述
栈的英文为(Stack)
栈是一个先入后出
(FILO-First In Last Out)的有序列表。
栈(stack)是限制
线性表中元素的插入
和删除
只能在线性表的同一端进行的一种特殊线性表。允许插入
和删除
的一端,为变化的一端,称为栈顶(Top);另一端为固定的一端,称为栈底(Bottom)。
根据栈的定义可知,最先放入栈中元素在栈底,最后放入的元素在栈顶,而删除元素刚好相反,最后放入的元素最先删除,最先放入的元素最后删除
1.2 图示
2. 栈的应用场景
2.1 子程序的调用
在跳往子程序前,会先将下个指令的地址存到堆栈中,直到子程序执行完后再将地址取出,以回到原来的程序中。
2.2 处理递归调用
和子程序的调用类似,只是除了储存下一个指令的地址外,也将参数、区域变量等数据存入堆栈中。
2.3 表达式的转换
[中缀表达式转后缀表达式]与求值(实际解决)。
2.4 二叉树的遍历
2.5 图形的深度优先(depth一first)搜索法
3. 栈的快速入门
3.1 数组模拟栈结构
3.1.1 数组模拟栈结构【思路分析(图示)】
3.1.2 数组模拟栈结构【代码实现】
package stack;
import java.util.Scanner;
/**
* @Author 小源同学
* @Date 2022 02 15 23 04
* @Describe 数组模拟栈实现
**/
public class StackArrayImpl {
public static void main(String[] args) {
//创建数据模拟的栈
ArrayStack arrayStack = new ArrayStack(3);
String key = "";
Scanner scanner = new Scanner(System.in);
boolean flag = true;//控制循环
while (flag) {
System.out.println("==========菜单==========");
System.out.println("push:添加数据到栈(入栈)==");
System.out.println("pop:取出栈的一个数据(出栈)");
System.out.println("list:遍历栈=============");
System.out.println("exit:退出循环===========");
System.out.println("==========菜单==========");
System.out.println();
System.out.print("请输入:");
key = scanner.next();
switch (key) {
case "push":
System.out.print("请输入要添加的数据:");
int value = scanner.nextInt();
arrayStack.push(value);
break;
case "pop":
arrayStack.pop();
break;
case "list":
arrayStack.listStack();
break;
case "exit":
flag = false;
break;
}
}
}
}
/**
* 用数组模拟栈
*/
class ArrayStack {
private int top = -1;//初始化指针,表示栈顶部
private int[] stack = null;
private int maxTop = -1;//栈最大容量(为了不让IDEA出现警告赋值为-1,因为封装了在实例化的时候该值会被覆盖)
public ArrayStack(int maxTop) {
this.maxTop = maxTop;
this.stack = new int[maxTop];
}
//判断栈满
public boolean isFull() {
return top == maxTop - 1;
}
//判断栈空的
public boolean isEmpty() {
return -1 != top;
}
//入栈操作
public void push(int value) {
//判断栈是否已经满了
if (!isFull()) {
this.stack[++top] = value;
return;
}
System.out.println("【入栈操作】栈满");
}
//出栈操作
public void pop() {
//判断栈是否为空
if (isEmpty()) {
System.out.printf("stack[%d] = %d\n", this.top, this.stack[top--]);
return;
}
System.out.println("【出栈操作】栈空");
}
//遍历栈
public void listStack() {
//判断栈是否为空
if (isEmpty()) {
for (int i = top; i >= 0; i--) {
System.out.printf("stack[%d] = %d \n", i, this.stack[i]);
}
return;
}
System.out.println("【遍历栈】栈空");
}
}
3.2 链表模拟栈结构
3.2.1 链表模拟栈结构【思路分析(图示)】
3.2.2 链表模拟栈结构【代码实现】
package stack;
import java.util.ArrayList;
import java.util.Scanner;
/**
* @Author 小源同学
* @Date 2022 02 15 23 04
* @Describe Please describe the role of this class
**/
public class StackLinkedImpl {
public static void main(String[] args) {
NodeInit nodeInit = new NodeInit(3);
String key = "";
Scanner scanner = new Scanner(System.in);
boolean flag = true;
while (flag) {
System.out.println("===========菜单==========");
System.out.println("push:添加数据到栈(入栈)===");
System.out.println("pop:取出栈的一个数据(出栈)=");
System.out.println("list:遍历栈==============");
System.out.println("exit:退出循环============");
System.out.println("==========菜单===========");
System.out.println();
System.out.print("请输入:");
switch (scanner.next()) {
case "push":
System.out.print("请输入要添加的数据:");
int value = scanner.nextInt();
nodeInit.push(new Node(value, null));
break;
case "pop":
nodeInit.pop();
break;
case "list":
nodeInit.list();
break;
case "exit":
flag = false;
break;
}
}
}
}
class NodeInit {
private int maxSize;//效仿数组:栈的最大长度(因为是链表,可以不用最大长度)
private Node head = new Node(0, null);
public NodeInit(int maxSize) {
this.maxSize = maxSize;
}
public int getMaxSize() {
return maxSize;
}
public void setMaxSize(int maxSize) {
this.maxSize = maxSize;
}
//判断栈满
public boolean isFull() {
if (isEmpty()) return false;
Node currNode = this.head.getNext();
int i = 0;//遍历节点的变量
while (null != currNode.getNext()) {
i++;
currNode = currNode.getNext();
}
return i == maxSize;
}
//判断栈空
public boolean isEmpty() {
Node currNode = head;
return null == currNode.getNext();
}
//入栈操作
public void push(Node node) {
if (!isFull()) {
Node currNode = head;
//获取最后一个节点,把数据挂在最后一个节点上
while (currNode.getNext() != null) currNode = currNode.getNext();
currNode.setNext(node);
return;
}
System.out.println("【入栈操作】栈满");
}
//出栈操作
public void pop() {
if (!isEmpty()) {
Node node = this.head;
Node popNode = node.getNext();//获取要移除的最后的节点
while (node.getNext().getNext() != null) {
node = node.getNext();
popNode = node.getNext();
}
System.out.println(popNode);
node.setNext(null);
return;
}
System.out.println("【出栈操作】栈空");
}
//遍历栈
public void list() {
if (!isEmpty()) {
ArrayList<Node> list = new ArrayList<>();
Node currNode = head.getNext();
while (currNode != null) {
list.add(currNode);
currNode = currNode.getNext();
}
for (int i = list.size() - 1; i >= 0; i--) System.out.println(list.get(i));
return;
}
System.out.println("【遍历栈】栈空");
}
}
class Node {
private int value;
private Node next;
public Node(int value, Node next) {
this.value = value;
this.next = next;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
@Override
public String toString() {
return "Node{" + "value=" + value + '}';
}
}
4. 使用栈计算表达式的结果
4.1 使用栈计算表达式【思路分析(图示)】
4.2 使用栈计算表达式【代码实现】
package stack;
/**
* @Author 小源同学
* @Date 2022 02 15 23 04
* @Describe 使用栈计算表达式
**/
public class StackEvaluation {
public static void main(String[] args) {
String express = "711*7*6-3+11";//表达式【29870】
//初始化数栈和符号栈
int maxTop = 10;//最大容量
ArrayStack2 numStack = new ArrayStack2(maxTop);//数栈
ArrayStack2 operStack = new ArrayStack2(maxTop);//符号栈
int index = 0, res = 0;//从栈里获取数,下标,运算结果
char value = ' ';//运算符,每次遍历获取的
StringBuilder spliceNum = new StringBuilder();//用于拼接多位数
do {
//依次获取表达式里的字符
value = express.substring(index, index + 1).charAt(0);
//判断是否是运算符
if (operStack.isOPer(value)) {
//是运算符
//判断栈是否为空
if (!operStack.isEmpty()) {
//符号栈不为空的情况,比较优先级
if (operStack.priority(value) <= operStack.priority(((char) operStack.peek()))) {
//当前优先级小于等于符号栈里运算符的优先级
//从数栈中获取两个数据
res = numStack.operations(numStack.pop(), numStack.pop(), ((char) operStack.pop()));
//运算结果存入数栈
numStack.push(res);
//当前获取的运算符存入符号栈
operStack.push(value);
} else {
//当前优先级大于符号栈里运算符的优先级,符号直接写入数栈
operStack.push(value);
}
} else {
//符号栈为空的情况,当前获取得到符号直接添加到符号栈
operStack.push(value);
}
} else {
//不是运算符的情况,直接把数字添加到数栈里
//char '1' :对应的十进制是49
//numStack.push(value - 48);
//这里还要处理如果这个数是两位或者3位
spliceNum.append(value);
//判断此时的下标时候走到了最后
while ((index != express.length() - 1) && !operStack.isOPer(express.substring(index + 1, index + 2).charAt(0))) {
spliceNum.append(express.substring(index + 1, index + 2).charAt(0));
index++;
}
numStack.push(Integer.parseInt(spliceNum.toString()));
spliceNum = new StringBuilder("");
}
index++;
} while (index < express.length());
//最后一步:当表达式扫描完毕,就顺序的从数栈和符号栈pop出相应的数字和符号,并运算
while (!operStack.isEmpty()) {
//当我们的符号栈为空的时候,我们的运算就已经结束了
res = numStack.operations(numStack.pop(), numStack.pop(), ((char) operStack.pop()));
numStack.push(res);
}
System.out.printf("表达式【" + express + "】的结果:%d", res);
}
}
//使用自己数组模拟的栈
class ArrayStack2 {
private int top = -1;//初始化指针,表示栈顶部
private int[] stack = null;
private int maxTop = -1;//栈最大容量(为了不让IDEA出现警告赋值为-1,因为封装了在实例化的时候该值会被覆盖)
public ArrayStack2(int maxTop) {
this.maxTop = maxTop;
this.stack = new int[maxTop];
}
//判断栈满
public boolean isFull() {
return top == maxTop - 1;
}
//判断栈空的
public boolean isEmpty() {
return -1 == top;
}
//查看栈顶的数据【即将被取出来的数据】
public int peek() {
return this.stack[top];
}
//入栈操作
public void push(int value) {
//判断栈是否已经满了
if (!isFull()) {
this.stack[++top] = value;
return;
}
System.out.println("【入栈操作】栈满");
}
//出栈操作
public int pop() {
//判断栈是否为空
if (isEmpty()) throw new RuntimeException("【出栈操作】栈空");
return this.stack[top--];
}
//遍历栈
public void listStack() {
//判断栈是否为空
if (isEmpty()) {
for (int i = top; i >= 0; i--) {
System.out.printf("stack[%d] = %d \n", i, this.stack[i]);
}
return;
}
System.out.println("【遍历栈】栈空");
}
//判断符号优先级 * / :1 ;+ -:0 数字越大优先级越高,这里只考虑 + - * /
public int priority(char value) {
if (value == '*' || value == '/') return 1;
else if (value == '+' || value == '-') return 0;
else return -1;//不存在的运算符号
}
//判断是否是运算符
public boolean isOPer(char value) {
return value == '*' || value == '/' || value == '+' || value == '-';
}
//做运算
public int operations(int num1, int num2, char oper) {
int res = 0;//储存结果
switch (oper) {
case '+':
res = num1 + num2;
break;
case '-':
res = num2 - num1;
break;
case '*':
res = num1 * num2;
break;
case '/':
res = num2 / num1;
break;
}
return res;
}
}
5. 表达式
前缀(波兰表达式)、中缀、后缀表达式(逆波兰表达式)
5.1 前缀表达式(波兰表达式)
前缀表达式又称波兰式,前缀表达式的运算符位于操作数之前
举例说明: (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6
5.1.1 前缀表达式的计算机求值
从右至左扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(栈顶元素 和 次顶元素),并将结果入栈;重复上述过程直到表达式最左端,最后运算得出的值即为表达式的结果
例如: (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6 , 针对前缀表达式求值步骤如下:
- 从右至左扫描,将6、5、4、3压入堆栈
- 遇到+运算符,因此弹出3和4(3为栈顶元素,4为次顶元素),计算出3+4的值,得7,再将7入栈
- 接下来是×运算符,因此弹出7和5,计算出7×5=35,将35入栈
- 最后是-运算符,计算出35-6的值,即29,由此得出最终结果
5.2 中缀表达式
- 中缀表达式就是常见的运算表达式,如(3+4)×5-6
- 中缀表达式的求值是我们人最熟悉的,但是对计算机来说却不好操作(前面我们讲的案例就能看的这个问题),因此,在计算结果时,往往会将中缀表达式转成其它表达式来操作(一般转成后缀表达式.)
5.3 后缀表达式(逆波兰表达式)
-
后缀表达式又称逆波兰表达式,与前缀表达式相似,只是运算符位于操作数之后
-
举例说明: (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 –
-
再比如:
正常的表达式 逆波兰表达式 a+b a b + a+(b-c) a b c - + a+(b-c)*d a b c – d * + a+d*(b-c) a d b c - * + a=1+3 a 1 3 + =
5.3.1 后缀表达式的计算机求值
从左至右扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(次顶元素 和 栈顶元素),并将结果入
栈;重复上述过程直到表达式最右端,最后运算得出的值即为表达式的结果
例如: (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下:
- 从左至右扫描,将3和4压入堆栈;
- 遇到+运算符,因此弹出4和3(4为栈顶元素,3为次顶元素),计算出3+4的值,得7,再将7入栈;
- 将5入栈;
- 接下来是×运算符,因此弹出5和7,计算出7×5=35,将35入栈;
- 将6入栈;
- 最后是-运算符,计算出35-6的值,即29,由此得出最终结果
6. 表达式练习题:逆波兰计算器
6.1 题目介绍
输入一个逆波兰表达式(后缀表达式),使用栈(Stack), 计算其结果
支持小括号和多位数整数,因为这里我们主要讲的是数据结构,因此计算器进行简化,只支持对整数的计算。
6.2 思路分析【图示】
6.3 代码实现
package stack;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Stack;
/**
* @Author 小源同学
* @Date 2022 02 15 23 04
* @Describe 逆波兰表达式
**/
public class ReversePolishExpress {
public static void main(String[] args) {
// ( 3 + 4 ) × 5 - 6
String express = "3 4 + 5 * 6 -";//【29】
//4 * 5 - 8 + 60 + 8 / 2
String express2 = "4 5 * 8 - 60 + 8 2 / +";//【76】
System.out.println("【(3+4)×5-6】对应的后缀表达式【" + express + "】的运算结果:" + accomplish(stringToList(express)));
System.out.println("【4*5-8+60+8/2 】对应的后缀表达式【" + express2 + "】的运算结果:" + accomplish(stringToList(express2)));
}
//string转List
private static List<String> stringToList(String str) {
if (str.equals("")) return null;
String[] s = str.split(" ");
return new ArrayList<>(Arrays.asList(s));
}
//实现逆表达式
/*
* 1. 从左至右扫描,将3和4压入堆栈;
* 2. 遇到+运算符,因此弹出4和3(4为栈顶元素,3为次顶元素),计算出3+4的值,得7,再将7入栈;
* 3. 将5入栈;
* 4. 接下来是×运算符,因此弹出5和7,计算出7×5=35,将35入栈;
* 5. 将6入栈;
* 6. 最后是-运算符,计算出35-6的值,即29,由此得出最终结果
*/
private static Integer accomplish(List<String> list) {
if (null == list) throw new RuntimeException("表达式异常");
//创建栈
Stack<Integer> numStack = new Stack<>();
int res = 0;//储存运算结果
for (String s : list) {
// if (!isOper(s)) { //方法一:这里是写的方法进行判断
if (s.matches("\\d+")) {//方法二:正则表达式:匹配的是多位数
numStack.push(Integer.parseInt(s));
} else {
res = doOperations(numStack.pop(), numStack.pop(), s);
numStack.push(res);
}
}
return numStack.peek();
}
//判断是否是运算符
private static boolean isOper(String oper) {
return oper.equals("+") || oper.equals("-") || oper.equals("*") || oper.equals("/");
}
//计算结果
public static int doOperations(int num1, int num2, String oper) {
int num = 0;//储存结果
switch (oper) {
case "+":
num = num1 + num2;
break;
case "-":
num = num2 - num1;
break;
case "*":
num = num1 * num2;
break;
case "/":
num = num2 / num1;
break;
default:
throw new RuntimeException("表达式的运算符有误");
}
return num;
}
}
7. 中缀表达式转换为后缀表达式
后缀表达式适合计算式进行运算,但是人却不太容易写出来,尤其是表达式很长的情况下,因此在开发中,我们需要将
中缀表达式转成后缀表达式
。
7.1 思路分析【图示】
7.2 代码实现
package stack;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
/**
* @Author 小源同学
* @Date 2022 02 15 23 04
* @Describe 中缀表达式转后缀表达式
**/
public class InfixToPostfix {
public static void main(String[] args) {
//中缀表达式 1+((2+3)×4)-5 [16]
String exp = "1+((2+3)*4)-5";
System.out.println("中缀表达式转后缀表达式:");
System.out.println("中缀表达式的List:" + infixToList(exp));
List<String> list = infixToPostfixExpression(infixToList(exp));
System.out.println("中缀表达式转后缀表达式的结果:" + ReversePolishExpress.accomplish(list));
}
//中缀表达式转后缀表达式
/**
* 1. 初始化两个栈:运算符栈s1和储存中间结果的栈s2;
* 2. 从左至右扫描中缀表达式;
* 3. 遇到操作数时,将其压s2;
* 4. 遇到运算符时,比较其与s1栈顶运算符的优先级:
* 4.1 如果s1为空,或栈顶运算符为左括号“(”,则直接将此运算符入栈;
* 4.2 否则,若优先级比栈顶运算符的高,也将运算符压入s1;
* 4.3 否则,将s1栈顶的运算符弹出并压入到s2中,再次转到(4.1)与s1中新的栈顶运算符相比较;
* 5. 遇到括号时:
* 5.1 如果是左括号“(”,则直接压入S1
* 5.2 如果是右括号“)”,则依次弹出s1栈顶的运算符,并压入s2,直到遇到左括号为止,此时将这一对括号丢弃
* 6. 重复步骤2至5,直到表达式的最右边
* 7. 将s1中剩余的运算符依次弹出并压入S2
* 8. 依次弹出s2中的元素并输出,结果的逆序即为中缀表达式对应的后缀表达式
*/
private static List<String> infixToPostfixExpression(List<String> exp) {
//把中缀转换为List的转换为后缀表达式
//初始化栈
Stack<String> s1 = new Stack<String>();//符号栈
// Stack<String> s2 = new Stack<String>();//中间过程栈
List<String> s2 = new ArrayList<>();//中间过程栈
for (String temp : exp) {
if (temp.matches("\\d+")) {//是数字
s2.add(temp);
} else if (temp.equals("(")) {
s1.add(temp);
} else if (temp.equals(")")) {
//如果temp获取的是")",则依次取出符号栈s1里的符号压入s2栈里,直到遇到"(",然后丢弃这一对括号
while (s1.size() != 0 && !s1.peek().equals("(")) {//如果不是"(",进入循环
s2.add(s1.pop());
}
s1.pop();//去除"("
} else {//表达式里不是:数字、(、)、的就是 + - * / 了
//如果temp的优先级小于符号栈s1的栈顶元素的优先级,将s1栈顶的运算符弹出并压入到s2中,再次转到(4.1)与s1中新的栈顶运算符相比较;
while (s1.size() != 0 && operPriority(temp) <= operPriority(s1.peek())) {
s2.add(s1.pop());
}
//当前的运算符temp 也要放入s2
s1.push(temp);
}
}
//将剩下的s1里的符号压入s2
while (s1.size() != 0) {
s2.add(s1.pop());
}
return s2;
}
//判断运算符的优先级
private static int operPriority(String oper) {
if (oper.equals("(")) return 0;
switch (oper) {
case "+":
case "-":
return 1;
case "*":
case "/":
return 2;
default:
// System.out.println("不提供" + oper + "的优先级");
return 0;
}
}
//将String中缀表达式转换为List
private static List<String> infixToList(String exp) {
List<String> strings = new ArrayList<>();
int i = 0;//指针
StringBuilder str = new StringBuilder();//对多位数进行拼接
char c = ' ';//获取的每一位
do {
c = exp.charAt(i);
if (c < 48 || c > 57) {//获取的是一个非数字
strings.add(String.valueOf(c));
} else {//获取的是一个数字
str.append(c);
// while (i != exp.length() - 1 && !isOper(String.valueOf(exp.charAt(i + 1)))) {//方法一
while (i != exp.length() - 1 && (exp.charAt(i + 1) >= 48 && exp.charAt(i + 1) <= 57)) {//方法二
str.append(exp.charAt(i + 1));
i++;
}
strings.add(str.toString());
str = new StringBuilder("");
}
i++;
//获取的是一个数字【与可能是多位数】
}
while (i < exp.length());
return strings;
}
}
8. 完整版的逆波兰计算器
8.1 代码实现
package stack;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Stack;
import java.util.regex.Pattern;
/**
* @Author 小源同学
* @Date 2022 02 15 23 04
* @Describe 完整版的逆波兰计算器
**/
public class ReversePolishMultiCalc {
/**
* 匹配 + - * / ( ) 运算符
*/
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
* @throws Exception
*/
public static List<String> doMatch (String s) throws Exception{
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.valueOf(s1) + Double.valueOf(s2); break;
case MINUS : result = Double.valueOf(s1) - Double.valueOf(s2); break;
case TIMES : result = Double.valueOf(s1) * Double.valueOf(s2); break;
case DIVISION : result = Double.valueOf(s1) / Double.valueOf(s2); break;
default : result = null;
}
return result;
}
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();
}
}
}