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();
}
}
}
31万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
