5.栈
问题引出：
1.栈的英文是stack
2.栈是一个先入后出的有序列表
3.栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。
允许插入和删除的一端，会变化的一端，称之为站栈顶(Top)
另外一端为固定的一端，称之为栈底(Bottom）
4.根据栈的定义可知,最先放入栈的元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放的元素最后删除。
栈的应用场景
1.子程序的调用：在跳往子程序前，会将下一个指令的地址存到堆栈中，直到此程序执行完后再将地址取出，以回到原来的程序中。
(类似jvm虚拟机栈中的程序记数器)
2.处理递归调用：和子程序的调用类似，只是除了存储下一个指令的地之外，也将参数、区域变量等数据存入到堆栈中。
3.表达式的转换【中缀表达式转后缀表达式】与求值(实际解决)
4.二叉树的遍历
5.图形的深度优先(depth-first)搜索法
代码实现：
class ArrayStack {
//数组模拟栈
private int[] stack;
//栈顶，初始为-1
private int top = -1;
//栈的最大容量
private int maxSize;
public ArrayStack(int maxSize) {
this.maxSize = maxSize;
this.stack = new int[maxSize];
}
/**
* 判断栈满
*
* @return
*/
public boolean isFull() {
return top == maxSize - 1;
}
/**
* 判断栈空
*
* @return
*/
public boolean isEmpty() {
return top == -1;
}
/**
* 入栈
*
* @param value 入栈的值
*/
public void push(int value) {
if (isFull()) {
System.out.println("栈已经满了");
return;
}
//栈顶上移一位，并赋值
stack[++top] = value;
}
/**
* 出栈
*
* @return 出栈的值
*/
public int pop() {
if (isEmpty()) {
throw new RuntimeException("栈已经空了！");
}
//取出栈顶的值，并将栈顶下移一位
return stack[top--];
}
/**
* 遍历栈
*/
public void listStack() {
for (int i = top; i >= 0; i--) {
System.out.println("出栈顺序：" + stack[i]);
}
}
}
测试：
public class ArrayStackDemo {
public static void main(String[] args) {
ArrayStack stack=new ArrayStack(4);
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
stack.listStack();
System.out.println("准备出栈-------");
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
}
}
输出：符合预期
出栈顺序：4
出栈顺序：3
出栈顺序：2
出栈顺序：1
准备出栈-------
4
3
2
1
Exception in thread "main" java.lang.RuntimeException: 栈已经空了！如何用栈实现综合计算器
输入一串字符串，得到表达式的结果：如3+2*6-2
逻辑分析：
开始1：以3+2*6*3-5*2为例
2.操作符操作数入栈
3.这下操作符*入栈，优先级大于栈中的+号，直接入栈
4.再入栈就是第二个*号，发现操作优先性和操作符栈第一个符号优先性一致，从数栈中拿出一个两个数，和符号栈中的一个符号进行操作
5.再进行入栈3
7.顺序pop并计算
代码示例
列表示例：
class ArrayStack1 {
//数组模拟栈
private int[] stack;
//栈顶，初始为-1
private int top = -1;
//栈的最大容量
private int maxSize;
public ArrayStack1(int maxSize) {
this.maxSize = maxSize;
this.stack = new int[maxSize];
}
/**
* 看一眼栈顶元素
*
* @return
*/
public int peek() {
return stack[top];
}
/**重点1：
* 返回运算符的优先级，优先级用数字表示
* 数字越大，优先级越高
*
* @param oper 运算符
* @return
*/
public int priority(int oper) {
if (oper == '*' || oper == '/') {
return 1;
} else if (oper == '-' || oper == '+') {
return 0;
} else {
//假定运算符只有加减乘除，这个代表异常
return -1;
}
}
/**重点2：
* 输入字符是否是运算符
*
* @param val
* @return
*/
public boolean isOper(char val) {
return val == '+' || val == '-' || val == '*' || val == '/';
}
/**重点3：
* 计算
*
* @param num1 第一个数
* @param num2 第二个数
* @param oper 操作符
* @return
*/
public int cal(int num1, int num2, int 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;
}
/**
* 判断栈满
*
* @return
*/
public boolean isFull() {
return top == maxSize - 1;
}
/**
* 判断栈空
*
* @return
*/
public boolean isEmpty() {
return top == -1;
}
/**
* 入栈
*
* @param value 入栈的值
*/
public void push(int value) {
if (isFull()) {
System.out.println("栈已经满了");
return;
}
//栈顶上移一位，并赋值
stack[++top] = value;
}
/**
* 出栈
*
* @return 出栈的值
*/
public int pop() {
if (isEmpty()) {
throw new RuntimeException("栈已经空了！");
}
//取出栈顶的值，并将栈顶下移一位
return stack[top--];
}
/**
* 遍历栈
*/
public void listStack() {
for (int i = top; i >= 0; i--) {
System.out.println("出栈顺序：" + stack[i]);
}
}中心代码：
public class Caluctor {
public static void main(String[] args) {
String expersion = "3+2*6-2";
//定义两个栈，一个操作数栈，一个符号栈
ArrayStack1 numStack = new ArrayStack1(10);
ArrayStack1 operStack = new ArrayStack1(10);
//用于扫描
int index = 0;
//用于计算的两个数
int num1 = 0;
int num2 = 0;
//操作符号
int oper = 0;
//返回结果
int res = 0;
//将每次扫描的char保存到ch中
char ch = ' ';
while (true) {
ch = expersion.charAt(index++);
//1.如果取出的是运算符
if (operStack.isOper(ch)) {
//1.1 判断操作符栈是否为空
if (!operStack.isEmpty()) {
//1.1.1 操作符号栈不为空，比较当前符号和操作符栈顶的优先级
if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
/*
如果当前的操作符优先级小于或者等于栈顶的操作符，就需要从操作数栈中pop两个数字
从符号栈中pop一个符号，进行计算，将得到的结果，如数栈，然后将当前操作符入符号栈
*/
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
res = numStack.cal(num1, num2, oper);
//将结果入数栈
numStack.push(res);
//将当前操作符如符号栈
operStack.push(ch);
} else {
//1.1.2 当前操作符的优先级大于栈中的操作符，直接入栈
operStack.push(ch);
}
} else {
//1.2操作符栈为空，直接入栈
operStack.push(ch);
}
} else {
/*
2.如果是数，直接入栈,这里需要注意的是整数和char的转换
例如：
String xml="123";
int num=xml.charAt(0);
输出num：49.
即char转的int-48，才是真正的值！
*/
numStack.push(ch - 48);
}
if (index >= expersion.length()) {
break;
}
}
//当表达式扫描完成后，就顺序的从操作数栈和符号栈取出对应值，进行平级计算
while (true) {
//操作符号栈为空，即计算结束，操作数栈会剩余一个数，即运算结果
if (operStack.isEmpty()) {
break;
}
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
res = numStack.cal(num1, num2, oper);
numStack.push(res);
}
System.out.println("表达式：" + expersion + "=" + numStack.pop());
}
}
输出：复合预期
表达式：3+2*6-2=13 问题：不能进行多位数运算：70*40+50
改动点：
定义一个String用于拼接多位数
//用于拼接
String keepNum="";
在放数这里，原始是直接放
/*
2.如果是数，直接入栈,这里需要注意的是整数和char的转换
例如：
String xml="123";
int num=xml.charAt(0);
输出num：49.
即char转的int-48，才是真正的值！
*/
numStack.push(ch - 48);
改为：
/*
分析思路：
1.当处理多为数是，不能发现是一个数就立即入栈，因为可能是多为数
2.在处理数时，需要向expression的表达式的index后再看一位，如果是数就继续扫描，如果是符号才入栈
3.因此我们需要定义一个变量，用于拼接
*/
keepNum += ch;
//考虑是否是最后一位
if (index == expersion.length()) {
numStack.push(Integer.valueOf(keepNum));
}else{
if (operStack.isOper(expersion.charAt(index))) {
numStack.push(Integer.valueOf(keepNum));
//重要：keepNum需要置空！
keepNum="";
}
}测试：
String expersion = "10+20*6-20";
测试输出：符合预期
表达式：10+20*6-20=110前缀、中缀、后缀表达式(逆波兰表达式)
前缀表达式(波兰表达式)
1.前缀表达式又称为波兰式，前缀表达式的运算符位于操作数之前
2.举例说明：(3+4)*5-6对应的前缀表达式就是 - x + 3 4 5 6
前缀表达式的计算机求值
从右向左扫描前缀表达式，遇到数字就将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对他们做相应的运算(栈顶元素和次顶元素)，
并将结果入栈，重复上述过程到表达式的最左端，最后运算得出的值即为表达式的结果
例如：(3+4)X5-6对应的前缀表达式为:- x + 3 4 5 6（注意这这里的符号不是随便添加顺序），针对前缀表达式的求值步骤如下，
- 从右向左扫描前缀表达式，将6、5、4、3压入堆栈
- 遇到+运算符，因此弹出3和4(3为栈顶元素，4为次顶元素)，计算出3+4的值，得7，再将7入栈
- 此时数栈内容为：栈顶-->栈底顺序：7-->5-->6
- 接着是X运算符，因此弹出7和5，计算出7*5=35，将35入栈
- 此时数栈内容为：栈顶-->栈底顺序：35-->6
- 最后是-运算符，计算出35-6即29.，得出结果(注意这里的顺序为:栈顶元素-次顶元素)
中缀表达式
1.中缀表达式就是最常见的运算表达式：如(3+4)x5-6
2.中缀表达式的求值是我们人最熟悉的，但是对计算机来说却不好操作(如前面的案例：需要判断各种操作符的优先级)，因此，在计算结果时，往往会将中缀表达式转成为其他表达式操作(一般转为后缀表达式)
后缀表达式(逆波兰表达式)
1.后缀表达式又称为逆波兰表达式，与前缀表达是相似，只是运算符位于操作数之后
2.举例：(3+4)X5-6对应的后缀表达式为：3 4 + 5 X 6 -（顺序并不是乱写的）
3.再比如
| 正常的表达式 | 逆波兰表达式 |
| 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 + = |
后缀表达式的计算机求值：
从左向右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对他们做相应的计算(栈顶元素和次顶元素)
并将结果入栈，重复上述过程，直到表达式最右端，最后运算得出的值即为表达式的结果。
例如：(3+4) X 5-6对应的后缀表达式为：3 4 + 5 X 6-,针对后缀表达式求值步骤如下：
1.从左向右扫描，将3和4压入队列
2.遇到+运算符，因此弹出4和3(4为栈顶元素，3为次顶元素)，计算出4+3的值，得7，再将7入栈
3.将5入栈
4.接下来是X运算符，因此弹出5和7，计算得到7X5=35,将35入栈
5.将6入栈
6.最后是-运算符，计算出35-6的值，即29，由此得到最终结果(次顶元素 操作 栈顶元素)
后缀表达式的代码示例：
public class PolandNotation {
public static void main(String[] args) {
//(3+4) X 5-6对应的后缀表达式为：3 4 + 5 X 6-
String suffixExpression = "3 4 + 5 * 6 -";
int result=calculate(suffixExpression);
System.out.println("计算结果为："+result);
}
/**
* 将后缀表达式转换为List，方便操作
*
* @param suffixExpression
* @return
*/
public static List<String> getListString(String suffixExpression) {
List<String> list = new ArrayList<>();
String[] split = suffixExpression.split(" ");
for (String item : split) {
list.add(item);
}
return list;
}
/**
* 根据狗追表达式计算
*
* @param suffixExpression
* @return
*/
public static int calculate(String suffixExpression) {
List<String> list = getListString(suffixExpression);
Stack<Integer> stack = new Stack<>();
int res = 0;
/*
1.从左向右扫描，将3和4压入队列
2.遇到+运算符，因此弹出4和3(4为栈顶元素，3为次顶元素)，计算出4+3的值，得7，再将7入栈
3.将5入栈
4.接下来是X运算符，因此弹出5和7，计算得到7X5=35,将35入栈
5.将6入栈
6.最后是-运算符，计算出35-6的值，即29，由此得到最终结果( )
*/
for (String item : list) {
//正则表达式，匹配多位数
if (item.matches("\\d+")) {
stack.push(Integer.valueOf(item));
} else {
int num1 = stack.pop();
int num2 = stack.pop();
switch (item) {
case "*":
res = num1 * num2;
break;
case "+":
res = num1 + num2;
break;
case "-":
res = num2 - num1;
break;
case "/":
res = num2 / num1;
break;
default:
throw new RuntimeException("符号错误！");
}
stack.push(res);
}
}
return stack.pop();
}
}
输出：复合预期
计算结果为：29
中缀表达式转换为后缀表达式(逆波兰表达式)
步骤：
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中元素并输出，结果的逆序即为中缀表达式对应的后缀表达式。
图示：以1+((2+3)*4-)-为例
1.
2.
3.
4.
5.
6.
7.
代码示例：
新增两个方法：
/**
* 获取输入运算符的优先级：数字越大优先级越高
*
* @param operation
* @return
*/
public static int getPriority(String operation) {
int result = 0;
switch (operation) {
case "*":
result = 2;
break;
case "/":
result = 2;
break;
case "+":
result = 1;
break;
case "-":
result = 1;
break;
default:
System.out.println("运算符错误！");
}
return result;
}
/**
* 将中缀字符串转换为中缀的list集合，方便后面的取值
*
* @param expression
* @return
*/
public static List<String> toInfixExpressionList(String expression) {
expression = expression.replaceAll("\\s*", "");
List<String> list = new ArrayList<>();
//索引
int index = 0;
//用于拼接复位数
String nums = "";
//标记取出的东西
String ch = "";
while (index < expression.length()) {
//如果是最后一位
if (index == expression.length() - 1) {
ch = expression.substring(index, index + 1);
nums += ch;
list.add(nums);
break;
}
ch = expression.substring(index, index + 1);
index++;
//是符号
if (!ch.matches("^[0-9]*$")) {
list.add(ch);
} else {
//是数字
nums += ch;
String next = expression.substring(index, index + 1);
//下一位不是符号位了，多位数拼接结束
if (!next.matches("^[0-9]*$")) {
list.add(nums);
nums = "";
}
}
}
return list;
}
真正中缀转后缀
/**
* 中缀表达式的list转后缀表达式的list
*
* @param infixExpressionList 中缀表达式list
* @return 后缀表达式list
*/
public static List<String> toPostfixExpression(List<String> infixExpressionList) {
//操作符栈s1
Stack<String> s1 = new Stack<>();
//中间结果存储，这里可以使用栈，使用list的原因是反转取值能方便点，因为最后的中缀表达式是中间结果栈的反序
List<String> s2 = new ArrayList<>();
/*
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中元素并输出，结果的逆序即为中缀表达式对应的后缀表达式。
*/
for (String item : infixExpressionList) {
//如果是数字直接入s2
if (item.matches("\\d+")) {
s2.add(item);
} else if ("(".equals(item)) {
s1.push(item);
} else if (")".equals(item)) {
//如果是有括号")",则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时这一对括号丢弃。
while (!"(".equals(s1.peek())) {
s2.add(s1.pop());
}
//如果是有括号")",则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时这一对括号丢弃。
s1.pop();
} else {
//剩余的就是加减乘除的操作符
/*
4.1 如果s1为空，或者栈顶运算符为左括号"(",则直接将此运算符入栈
4.2 否则，比较与s1的栈顶优先级，如果优先级比栈顶运算符的高，也将运算符入栈
4.3 否则，将s1栈顶的运算符弹出并压入s2中，再次转到4.1与s1中心得栈顶运算符比较
*/
while (true) {
//这里代码可以优化，但是这样思路更清晰
if (s1.isEmpty() || "(".equals(s1.peek())) {
s1.push(item);
break;
} else {
//比较与s1的栈顶优先级，如果优先级比栈顶运算符的高，也将运算符入栈
if (getPriority(item) > getPriority(s1.peek())) {
s1.push(item);
break;
} else {
s2.add(s1.pop());
}
}
}
}
}
while (!s1.isEmpty()){
s2.add(s1.pop());
}
return s2;
}
上述优化可以改为：
while (true) {
if (s1.isEmpty() || "(".equals(s1.peek()) || getPriority(item) > getPriority(s1.peek())) {
s1.push(item);
break;
} else {
//比较与s1的栈顶优先级，如果优先级比栈顶运算符的高，也将运算符入栈
s2.add(s1.pop());
}
}
输出：
中缀表达式：1+((2+3)*4)-5
中缀表达式的list：[1, +, (, (, 2, +, 3, ), *, 4, ), -, 5]
后缀表达式的list：[1, 2, 3, +, 4, *, +, 5, -]
