目录
栈
简介：
- 栈的英文为(stack)
- 栈是一个先入后出(FILO-First In Last Out)的有序列表。
- 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
- 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除 。
- 出栈(pop)和入栈(push)。
应用：
- 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
- 处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
- 表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。
- 二叉树的遍历。
- 图形的深度优先(depth一first)搜索法。
分析步骤：
- 1. 定义top表示栈顶，初始化为-1;
- 2. 入栈，top++;stack[top]=data;
- 3. 出栈，int value=stack[top];top--;return value;
代码：
package com.jiao.dataStructure;
import java.util.Scanner;
public class ArrayStackDemo {
public static void main(String[] args) {
ArrayStack stack = new ArrayStack(4); //创建对象
String key = ""; //用户输入
Boolean loop = true; //控制程序
Scanner scanner = new Scanner(System.in); //用户输入
while (loop) {
System.out.println("show:显示栈");
System.out.println("pop:从栈取数据(出栈)");
System.out.println("push:添加数据到栈(入栈)");
System.out.println("exit:退出程序");
System.out.println("请输入你的选择: ");
key = scanner.next(); //获取用户输入
switch (key) {
case "show":
stack.list();
break;
case "pop":
try {
int result = stack.pop();
System.out.printf("出栈的数据是:%d \n",result);
} catch (Exception e) {
System.out.println(e.getMessage());
}
break;
case "push":
System.out.println("请输入要加入的数:");
int num = scanner.nextInt(); //接收用户入栈的数
stack.push(num);
break;
case "exit":
scanner.close(); //关闭输入，以防数据泄露
loop = false;
break;
default:
System.out.println("输入的选择不对，请重新选择~");
break;
}
}
System.out.println("程序退出~");
}
}
//定义一个ArrayStack 表示栈
class ArrayStack {
private int maxSize; //栈的大小maxSize
private int[] stack; //数组模拟栈stack
private int top=-1; //栈顶top=-1
//构造器
public ArrayStack(int maxSize) {
this.maxSize = maxSize;
stack = new int[this.maxSize]; //maxSize大小的数组表示的栈
}
//栈满isFull
public boolean isFull() {
return top == maxSize - 1;
}
//栈空isEmpty
public boolean isEmpty() {
return top == -1;
}
//入栈-push
public void push(int value) {
if (isFull()) { //判断栈满
System.out.println("栈满~");
return;
}
top++;
stack[top] = value;
}
//出栈-pop，返回栈顶的数据
public int pop() {
if (isEmpty()) { //判断栈空
throw new RuntimeException("栈空~"); //抛出异常
}
int value = stack[top];
top--;
return value;
}
//显示 遍历栈 list 从栈顶开始
public void list() {
if (isEmpty()) { //判断栈空
System.out.println("栈空~无数据");
}
for (int i = top; i >=0 ; i--) {
System.out.printf("stack[%d]=%d \n",i,stack[i]);
}
}
}测试结果：
作业：用链表模拟栈[单向链表]------------待做
计算器应用【中缀表达式】：
思路：
- 1. 通过一个index值(索引),来遍历表达式;
- 2. 如果是数字就入数栈(numStack);
- 3. 如果是符号分两种情况讨论: 3.1 假如当前符号栈为空,直接入栈; 3.2 假如符号栈有操作符,进行比较: A: 如果当前操作符的优先级小于或者等于栈中的操作符,先从数据栈中pop两个数,从符号栈pop一个符号,运算得到的结果入数据栈,将当前的操作符入符号栈; B: 如果当前操作符的优先级大于栈中的操作符,直接入符号栈;
- 4. 当表达式扫描完毕,就顺序的从数据栈和符号栈中pop出相应的数和符号,并运算;
- 5.最后数栈只有一个数字就是表达式的结果.
代码：
package com.jiao.dataStructure;
public class Calculator {
public static void main(String[] args) {
//表达式
String expression = "3+2*6-2";
//创建numStack和operStack
ArrayStack2 numStack = new ArrayStack2(10);
ArrayStack2 operStack = new ArrayStack2(10);
//定义变量
int index = 0; //对表达式的索引
int num1 = 0;
int num2 = 0;
int oper = 0;
int res = 0; //入栈出栈的 两数一操作符一结果
char ch = ' '; //挨个扫描表达式的字符变量
while (true) {
//挨个获取表达式字符
ch = expression.substring(index,index+1).charAt(0);
if (operStack.isOper(ch)) { //3.判断是字符
if (!operStack.isEmpty()) { //3.2假如当前符号栈不为空
//A. 如果当前操作符的优先级小于或者等于栈中的操作符,先从数据栈中pop两个数,
// 从符号栈pop一个符号,运算得到的结果入数据栈,将当前的操作符入符号栈;
if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
res = numStack.cal(num1,num2,oper);
numStack.push(res);
operStack.push(ch);
} else {
//B: 如果当前操作符的优先级大于栈中的操作符,直接入符号栈;
operStack.push(ch);
}
} else { //3.1假如当前符号栈为空
operStack.push(ch);
}
} else { //2.判断是数字
numStack.push(ch - 48); //ch是字符，假如直接push会是ASCII码的数字
}
index++;
if (index >= expression.length()) { //表达式遍历结束
break;
}
}
//4. 当表达式扫描完毕,就顺序的从数据栈和符号栈中pop出相应的数和符号,并运算;
while (true) {
if (operStack.isEmpty()) {
break;
}
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
res = numStack.cal(num1,num2,oper);
numStack.push(res);
}
//5.最后数栈只有一个数字就是表达式的结果.
int result = numStack.pop();
System.out.printf("表达式:%s;计算结果:%d",expression,result);
}
}
//定义一个ArrayStack2 表示栈 增加功能
class ArrayStack2 {
private int maxSize; //栈的大小maxSize
private int[] stack; //数组模拟栈stack
private int top=-1; //栈顶top=-1
//构造器
public ArrayStack2(int maxSize) {
...
}
//栈满isFull
public boolean isFull() {
...
}
//栈空isEmpty
public boolean isEmpty() {
...
}
//入栈-push
public void push(int value) {
...
}
//出栈-pop，返回栈顶的数据
public int pop() {
...
}
//显示 遍历栈 list 从栈顶开始
public void list() {
...
}
//1. 返回运算符的优先级
public int priority(int oper) {
if (oper == '*' || oper == '/') {
return 1;
} else if (oper == '+' || oper == '-') {
return 0;
} else {
return -1;
}
}
//2. 判断是不是一个运算符
public boolean isOper(int val) {
return val == '+' || val == '-' || val == '*' || val == '/';
}
//3. 计算方法
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;
default:
break;
}
return res;
}
//4. 返回当前栈顶的值,不是pop
public int peek() {
return stack[top];
}
}测试结果：
解决多位数问题：
修改代码：
String keepNum = ""; //存放多位数
//多位数 往后再看一位
keepNum += ch;
if (index == expression.length() - 1) { //表达式最后一位
numStack.push(Integer.parseInt(keepNum));
} else {
if (operStack.isOper(expression.substring(index+1,index+2).charAt(0))) { //当前字符的下一个为操作符
numStack.push(Integer.parseInt(keepNum));
keepNum = "";
}
}测试结果：
作业：表达式添加()括号运算。---------待完成
前缀表达式(波兰表达式)的计算机求值：
从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素 和 次顶元素），并将结果入栈；重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果。
例如: (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6 , 针对前缀表达式求值步骤如下:
1）从右至左扫描，将6、5、4、3压入堆栈
2）遇到+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素），计算出3+4的值，得7，再将7入栈
3）接下来是×运算符，因此弹出7和5，计算出7×5=35，将35入栈
4）最后是-运算符，计算出35-6的值，即29，由此得出最终结果后缀表达式(逆波兰表达式)的计算机求值：
从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素 和 栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果。
例如: (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下:
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，由此得出最终结果逆波兰计算器（基于Stack栈）：
代码：
package com.jiao.dataStructure;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class PolandNotation {
public static void main(String[] args) {
//1 定义逆波兰表达式 (3+4)*5-6 => 3 4 + 5 * 6 -
String suffixExpression = "3 4 + 5 * 6 -";
//2.1 将字符串表达式放在ArrayList中(定义一个方法)
List<String> list = getListString(suffixExpression);
System.out.println("ArrayList中的值："+list);
//2.2 list与stack结合(定义一个方法)
int result = calculate(list);
System.out.println("result="+result);
}
//将逆波兰表达式数字和运算法依次存放在ArrayList中
public static List<String> getListString(String suffixExpression) {
//a. 将字符串以空格分割放在数组中
String[] su = suffixExpression.split(" ");
//b. 定义list
List<String> list = new ArrayList<>();
//c. 遍历
for (String s : su) {
list.add(s);
}
return list;
}
//对逆波兰表达式的计算
public static int calculate(List<String> list) {
//a. 创建一个栈
Stack<String> stack = new Stack<>();
//b. 遍历list
for (String s : list) {
//c. 数字入栈，遇到操作符两数字出栈计算后的结果再入栈,以此类推
if (s.matches("\\d+")) { //正则表达式匹配多位数
stack.push(s); //数字入栈
} else {
int num2 = Integer.parseInt(stack.pop()); //字符数字转Integer
int num1 = Integer.parseInt(stack.pop());
int res = 0;
if ("+".equals(s)) { //操作符+
res = num1 + num2;
} else if ("-".equals(s)) { //操作符-
res = num1 - num2;
} else if ("*".equals(s)) { //操作符*
res = num1 * num2;
} else if ("/".equals(s)) { //操作符/
res = num1 / num2;
} else {
throw new RuntimeException("操作符错误~");
}
stack.push("" + res); //int类型的计算结果sum转化为String入栈继续下一轮
//stack.push(String.valueOf(sum));
}
}
//d. 栈存入的是结果
return Integer.parseInt(stack.pop()); //栈里是String,转int计算结果返回
}
}测试结果：
中缀表达式转后缀表达式：
具体步骤如下:
- 1.初始化两个栈：运算符栈s1和储存中间结果的栈s2；
- 2.从左至右扫描中缀表达式；
- 3.遇到操作数时，将其压s2；
- 4.遇到运算符时，比较其与s1栈顶运算符的优先级：
- 4.1如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
- 4.2否则，若优先级比栈顶运算符的高，也将运算符压入s1；
- 4.3否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较；
- 5.遇到括号时：
- (1) 如果是左括号“(”，则直接压入s1
- (2) 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
- 6.重复步骤2至5，直到表达式的最右边
- 7.将s1中剩余的运算符依次弹出并压入s2
- 8.依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
举例说明: 将中缀表达 式“1+((2+3)×4)-5”转 换为后缀表达式，结果为 "1 2 3 + 4 × + 5 –"
代码段：
package com.jiao.dataStructure;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class PolandNotation {
public static void main(String[] args) {
//A。 中缀表达式转后缀表达式
String expression = "1+((2+3)*4)-5";
//B. 中缀的str转中缀的list
List<String> infixExpressionList = toInfixExpressionList(expression);
System.out.println("中缀str转中缀list的infixExpressionList="+infixExpressionList);
//C. 中缀的list转后缀list
List<String> suffixExpressionList = parseSuffixExpressionList(infixExpressionList);
System.out.println("中缀list转后缀list的suffixExpressionList="+suffixExpressionList);
//计算测试
int result = calculate(suffixExpressionList);
System.out.println("expression:"+expression+"的计算结果为:"+result);
}
// C. 中缀转后缀list
public static List<String> parseSuffixExpressionList(List<String> ls) {
//1.初始化两个栈：运算符栈s1和储存中间结果的栈s2；
Stack<String> s1 = new Stack<>(); //运算符栈
List<String> s2 = new ArrayList<>(); //存储中间结果栈，由于只进不出，可以用List代替，最后也可以不用反转
//2.从左至右扫描中缀表达式； 6.重复步骤2至5，直到表达式的最右边
for (String item : ls) {
//3.遇到操作数时，将其压s2；
if (item.matches("\\d+")) {
s2.add(item);
} else if ("(".equals(item)) { //5.(1) 如果是左括号“(”，则直接压入s1
s1.push(item);
} else if (")".equals(item)) { //5.(2) 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
while (!s1.peek().equals("(")) { //s1.peek()获取栈顶元素但是不pop出
s2.add(s1.pop());
}
s1.pop(); //pop掉“(”
} else {
//4.1如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
//4.3否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较；
while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
s2.add(s1.pop());
}
//4.2否则，若优先级比栈顶运算符的高，也将运算符压入s1；
s1.push(item);
}
}
//7.将s1中剩余的运算符依次弹出并压入s2
while (s1.size() != 0) {
s2.add(s1.pop());
}
//8.依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
return s2;
}
// B. 中缀表达式转List 使用一个”指针“
public static List<String> toInfixExpressionList(String s) {
//定义ls
List<String> ls = new ArrayList<>();
int i = 0; //指针用于遍历
String str; //对多位数拼接
char c; //每遍历一个字符，放到c里面
do {
//非数字直接加到ls中 48~57 => ASCII 是0~9
if ((c=s.charAt(i)) < 48 || (c=s.charAt(i)) > 57) {
ls.add(""+c);
i++;
}else { //数字考虑多位数
str = "";
while (i < s.length() && (c=s.charAt(i)) >= 48 && (c=s.charAt(i)) <= 57) {
str += c; //拼接
i++;
}
ls.add(str);
}
} while (i < s.length());
return ls;
}
//将逆波兰表达式数字和运算法依次存放在ArrayList中
public static List<String> getListString(String suffixExpression) {...}
//对逆波兰表达式的计算
public static int calculate(List<String> list) {...}
}
//写一个比较运算符优先级的类
class Operation {
private static int ADD = 1;
private static int SUB = 1;
private static int MUL = 2;
private static int DIV = 2;
//写个方法返回优先级的数字
public static int getValue(String operation) {
int result = 0;
switch (operation) {
case "+":
result = ADD;
break;
case "-":
result = SUB;
break;
case "*":
result = MUL;
break;
case "/":
result = DIV;
break;
default:
System.out.println("操作数不存在~");
break;
}
return result;
}
}测试结果：
作业：逆波兰计算器完整版 -----【待完成】
（1）支持 + - * / ( )
（2）多位数，支持小数,
（3）兼容处理, 过滤任何空白字符，包括空格、制表符、换页符
递归
调用机制：
psvm:test(4)
...
public static void test(int n) {
if (n > 2) {
test(n - 1);
}
System.out.println("n=" + n);
}
图解分析：
迷宫回溯问题：
代码分析：
package com.jiao.dataStructure;
public class MiGong {
public static void main(String[] args) {
//1. 先创建一个二维数组，模拟迷宫
//1.1 定义地图8*7
int[][] map = new int[8][7];
//1.2 墙 1 ; 挡板 1
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
if (i == 0 || i == 7) { //横墙
map[i][j] = 1;
}
if (j == 0 || j == 6) { //竖墙
map[i][j] = 1;
}
if ((i == 3 && j == 1) || i == 3 && j == 2) { //障碍
map[i][j] = 1;
}
/*if ((i == 1 && j == 2) || i == 2 && j == 2) {
map[i][j] = 1;
}*/
}
}
//2.输出map
System.out.println("Map:");
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
System.out.printf("%d ",map[i][j]);
}
System.out.println();
}
//3.调用递归方法
boolean flag = setWay(map, 1, 1);
System.out.println("flag:"+flag);
System.out.println("Map路径:");
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
System.out.printf("%d ",map[i][j]);
}
System.out.println();
}
}
/**
* 方法功能：使用递归回溯给小球找路
* 约定：1.开始[1][1],结束[6][5]
* 2.map[i][j]=0没走过,=1为墙,=2通路可以走,=3已经走过但是走不通
* 3.策略：下->右->上->左,走不通,再回溯
* @param map 表示地图
* @param i 从哪个位置开始找
* @param j
* @return 找到通路返回true,否则返回false
*/
public static boolean setWay(int[][] map,int i,int j) {
if (map[6][5] == 2) { //1. 走到终点
return true;
} else { //2. 没找到终点
if (map[i][j] == 0) { //2.1 当前没走过
map[i][j] = 2; //走过标记
if (setWay(map,i+1,j)) { //2.1.1 向下走
return true;
} else if (setWay(map,i,j+1)) { //2.1.2 向右走
return true;
} else if (setWay(map,i-1,j)) { //2.1.3 向上走
return true;
} else if (setWay(map,i,j-1)) { //2.1.4 向左走
return true;
} else { //2.1.5 走不通 3
map[i][j] = 3;
return false;
}
} else { // map[i][j] == 1 2 3
return false;
}
}
}
}测试结果：
作业：最短路径 -----【待做】
八皇后问题（回溯算法）：
八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。
八皇后问题算法思路分析：
- 第一个皇后先放第一行第一列
- 第二个皇后放在第二行第一列、然后判断是否OK， 如果不OK，继续放在第二列、第三列、依次把所有列都放完，找到一个合适
- 继续第三个皇后，还是第一列、第二列……直到第8个皇后也能放在一个不冲突的位置，算是找到了一个正确解
- 当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到.
- 然后回头继续第一个皇后放第二列，后面继续循环执行 1,2,3,4的步骤
说明：理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题. arr[8] = {0 , 4, 7, 5, 2, 6, 1, 3} //对应arr 下标 表示第几行，即第几个皇后，arr[i] = val , val 表示第i+1个皇后，放在第i+1行的第val+1列。
代码：
package com.jiao.dataStructure;
public class Queue8 {
//定义一个max表示有多少个皇后
int max = 8;
//定义一个一维数组array,保存皇后放置位置的结果，比如arr={0,4,7,5,2,6,1,3}
int[] array = new int[max];
static int count = 0; //计算有多少种方法
public static void main(String[] args) {
Queue8 queue8 = new Queue8();
queue8.check(0);
System.out.println("count:"+count);
}
//编写一个递归方法，放置第n个皇后
private void check(int n) {
if (n == 8) { //找到一组排列并完成打印
count++;
print();
return;
}
//依次放入皇后判断是否冲突
for (int i = 0; i < max; i++) {
//先把当前皇后n，放入该行1列
array[n] = i;
//判断当放置第n个皇后到i列时，是否冲突
if (judge(n)) { //不冲突
check(n+1);
}
//冲突的话会回溯进行调整，即执行array[i]=n
}
}
//查看当我们 放置第n个皇后后,就去检测该皇后是否和前面已经给摆放的皇后冲突 n为第n个皇后
private boolean judge(int n) {
//判断列或者斜边是否冲突,前几个皇后都要判断
for (int i = 0; i < n; i++) {
if (array[i] == array[n] || Math.abs(n-i) == Math.abs(array[n]-array[i])) {
return false; //冲突
}
}
return true; //不冲突
}
//写一个方法，可以将皇后摆放的位置打印输出出来
private void print() {
for (int i = 0; i < array.length; i++) {
System.out.printf("%d ",array[i]);
}
System.out.println();
}
}测试结果：
748
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
