索引
数据结构
- 数据结构是算法的基础
- 数据结构包括：线性结构和非线性结构。
线性结构
- 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系
- 线性结构有两种不同的存储结构，即顺序存储结构(数组)和链式存储结构(链表)。
- 顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的(在连续的一片地址中)
- 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息
- 线性结构常见的有：数组、队列、链表和栈
非线性结构
非线性结构包括：二维数组，多维数组，广义表，树结构，图结构
一、稀疏 sparsearray 数组
-
引出：五子棋程序：存盘退出和读取存档功能：
利用一个二维数组保存棋盘数据->很多值是默认值, 因此记录了很多没有意义的数据 -
稀疏数组：当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。
-
稀疏数组的处理方法是:
记录数组一共有几行几列，有多少个不同的值
把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
4. 思路分析：
二维数组->稀疏数组
- 遍历原始二维数组，得到有效数据的个数 sum；
- 根据sum 创建稀疏数组；
- 将有效数据存入 稀疏数组；
稀疏数组->二维数组
- 读取稀疏数组 1行1列，创建二维数组；
- 读取剩下数据赋给 二维数组
public static void main(String[] args) {
// 创建一个原始的二维数组 11 * 11
// 0: 表示没有棋子， 1 表示 黑子 2 表蓝子
int chessArr1[][] = new int[11][11];
chessArr1[1][2] = 1;
chessArr1[2][3] = 2;
chessArr1[4][5] = 2;
// 输出原始的二维数组（按行遍历）
System.out.println("原始的二维数组~~");
for (int[] row : chessArr1) {
for (int data : row) {
System.out.printf("%d\t", data);
}
System.out.println();
}
// 将二维数组 转 稀疏数组的思想
// 1. 先遍历二维数组 得到非0数据的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (chessArr1[i][j] != 0) {
sum++;
}
}
}
// 2. 创建对应的稀疏数组
int sparseArr[][] = new int[sum + 1][3];
// 给稀疏数组赋值
sparseArr[0][0] = 11;
sparseArr[0][1] = 11;
sparseArr[0][2] = sum;
// 遍历二维数组，将非0的值存放到 sparseArr中
int count = 0; //count 用于记录是第几个非0数据
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (chessArr1[i][j] != 0) {
count++;
sparseArr[count][0] = i;
sparseArr[count][1] = j;
sparseArr[count][2] = chessArr1[i][j];
}
}
}
//将稀疏数组 恢复成原始的二维数组
//1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
//2. 在读取稀疏数组后几行的数据(从第二行开始)，并赋给 原始的二维数组 即可
for (int i = 1; i < sparseArr.length; i++) {
chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
}
}
}
二、队列介绍
- 队列是一个有序列表，可以用数组或是链表来实现。
- 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出
- 示意图：(使用数组模拟队列示意图)
思路分析：
- 用一维数组来模拟队列；
- 队列要有添加、取出数据；
- 由以上可得构建一个类对象（队列），他有属性（MaxSize、rear、数组等），调用其方法add、get。
class ArrayQueue {
private int maxSize; // 表示数组的最大容量
private int front; // 队列头
private int rear; // 队列尾
private int[] arr; // 该数据用于存放数据, 模拟队列
// 创建队列的构造器
public ArrayQueue(int arrMaxSize) {
maxSize = arrMaxSize;
arr = new int[maxSize];
front = -1; // 指向队列头部，分析出front是指向队列头的前一个位置.
rear = -1; // 指向队列尾，指向队列尾的数据(即就是队列最后一个数据)
}
// 判断队列是否满
public boolean isFull() {
return rear == maxSize - 1;
}
// 判断队列是否为空
public boolean isEmpty() {
return rear == front;
}
// 添加数据到队列
public void addQueue(int n) {
// 判断队列是否满
if (isFull()) {
System.out.println("队列满，不能加入数据~");
return; //方法没有返回值时 return结束方法；
}
rear++; // 让rear 后移
arr[rear] = n;
}
// 获取队列的数据, 出队列
public int getQueue() {
// 判断队列是否空
if (isEmpty()) {
// 方法有返回值时，通过抛出异常，结束方法
throw new RuntimeException("队列空，不能取数据");
}
front++; // front后移
return arr[front];
}
// 显示队列的所有数据
public void showQueue() {
// 遍历
if (isEmpty()) {
System.out.println("队列空的，没有数据~~");
return;
}
for (int i = front + 1; i <= rear; i++) {
System.out.println(arrs[i]);
}
}
// 显示队列的头数据， 注意不是取出数据
public int headQueue() {
// 判断
if (isEmpty()) {
throw new RuntimeException("队列空的，没有数据~~");
}
return arr[front + 1];
}
}
测试：
public static void main(String[] args) {
//创建一个队列
ArrayQueue queue = new ArrayQueue(3);
char key = ' '; //接收用户输入
Scanner scanner = new Scanner(System.in);//
boolean loop = true;
//输出一个菜单
while (loop) {
System.out.println("s(show): 显示队列");
System.out.println("e(exit): 退出程序");
System.out.println("a(add): 添加数据到队列");
System.out.println("g(get): 从队列取出数据");
System.out.println("h(head): 查看队列头的数据");
key = scanner.next().charAt(0); //接收一个字符
switch (key) {
case 's':
queue.showQueue();
break;
case 'a':
System.out.println("输出一个数");
int value = scanner.nextInt();
queue.addQueue(value);
break;
case 'g': //取出数据
try {
int res = queue.getQueue();
System.out.printf("取出的数据是%d\n", res);
} catch (Exception e) {
// TODO: handle exception
System.out.println(e.getMessage());
}
break;
case 'h': //查看队列头的数据
try {
int res = queue.headQueue();
System.out.printf("队列头的数据是%d\n", res);
} catch (Exception e) {
// TODO: handle exception
System.out.println(e.getMessage());
}
break;
case 'e': //退出
scanner.close();
loop = false;
break;
default:
break;
}
}
System.out.println("程序退出~~");
}
问题分析并优化
- 目前数组使用一次就不能用， 没有达到复用的效果
- 将这个数组使用算法，改进成一个环形的队列 取模：%（在rear后移时）
rear =（rear + 1）% maxSize
class CircleArray {
private int maxSize; // 表示数组的最大容量
private int front;
private int rear;
private int[] arr;
public CircleArray(int arrMaxSize) {
maxSize = arrMaxSize;
arr = new int[maxSize];
//其他两个默认值为0
}
// 判断队列是否满
public boolean isFull() {
return (rear + 1) % maxSize == front;
}
// 判断队列是否为空
public boolean isEmpty() {
return rear == front;
}
// 添加数据到队列 入队列操作rear
public void addQueue(int n) {
// 判断队列是否满
if (isFull()) {
System.out.println("队列满，不能加入数据~");
return;
}
//直接将数据加入
arr[rear] = n;
//将 rear 后移, 这里必须考虑取模
rear = (rear + 1) % maxSize;
}
// 获取队列的数据, 出队列操作front
public int getQueue() {
// 判断队列是否空
if (isEmpty()) {
// 通过抛出异常
throw new RuntimeException("队列空，不能取数据");
}
// 这里需要分析出 front是指向队列的第一个元素
// 1. 先把 front 对应的值保留到一个临时变量
// 2. 将 front 后移, 考虑取模
// 3. 将临时保存的变量返回
int value = arr[front];
front = (front + 1) % maxSize;
return value;
}
// 显示队列的所有数据
public void showQueue() {
// 遍历
if (isEmpty()) {
System.out.println("队列空的，没有数据~~");
return;
}
// 思路：从front开始遍历，遍历多少个元素
// front指向第一个数据，调用size()得到此时队列有几个有效数据
for (int i = front; i < front + size() ; i++) {
System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
}
}
// 求出当前队列有效数据的个数
public int size() {
// rear = 2
// front = 1
// maxSize = 3
return (rear + maxSize - front) % maxSize;
}
// 显示队列的头数据， 注意不是取出数据
public int headQueue() {
// 判断
if (isEmpty()) {
throw new RuntimeException("队列空的，没有数据~~");
}
return arr[front];
}
}
三、单链表
- 链表是以节点的方式来存储,是链式存储
- 每个节点包含 data 域， next 域：指向下一个节点.
- 发现链表的各个节点不一定是连续存储.
- 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定
使用带 head 头的单向链表实现：链表的增删改查：
1、实现单链表
单链表由多个节点组成
可以将各个节点看作是一个节点对象
定义节点类
class Node {
public int num;
public String name;
public Node next;
public Node(int num, String name) {
this.num = num;
this.name = name;
}
toString方法用于打印
}
单链表类： 初始化一个头节点，提供增删改查方法
class SingleLinkedList {
private Node head = new Node(0, "");
public void add(Node node) {}
...
}
2、增加：两种方法
一是只能加入到最后，二是根据次序插入到指定位置(如果已有，则添加失败，并给出提示)
public void add(Node node) {
Node temp;
temp = head;
while (true) {
if (temp.next != null) {
temp = temp.next;
} else {
temp.next = node;
break;
}
}
}
public void addByOrder(Node node) {
Node temp = head;
boolean flag = false;
while (true) {
if (temp.next == null) { //说明 temp 已经在链表的最后
break;
}
if (temp.next.num > node.num) {
//位置找到，就在 temp 的后面插入
break;
} else if (temp.next.num == node.num) {
//说明希望添加的 heroNode 的编号已然存在
flag = true; //说明编号存在
break;
}
temp = temp.next;
}
if (flag) {
System.out.printf("已经存在了, 不能加入");
} else {
node.next = temp.next;
temp.next = node;
}
}
}
2、修改
(1)先找到该节点，通过遍历
(2) temp.name = node.name
public void update(Node newNode) {
if (head.next == null) {
System.out.println("链表为空");
return;
}
Node temp = head.next;
boolean flag = false;
while (true) {
if (temp == null) {
break;
}
if (temp.num == newNode.num) {
flag = true;
break;
}
temp = temp.next;
}
if (flag) {
temp.name = newNode.name;
} else {
System.out.println("没有找到");
}
}
2、删除
//1. head 不能动，因此我们需要一个 temp 辅助节点找到待删除节点的前一个节点
//2. 说明我们在比较时，是 temp.next.no 和 需要删除的节点的 no 比较
public void del(int id){
boolean flag = false;
Node temp = head;
while (true){
if (temp.next == null){
break;
}
if (temp.next.num == id){
flag = true;
break;
}
temp = temp.next;
}
if (flag){
temp.next = temp.next.next;
}else {
System.out.println("要删除的节点不存在");
}
}
3、统计有效个数
思路：设计方法，通过辅助变量遍历这个链表，逐一统计个数即可
public int length(Node head){
if (head.next == null){
return 0;
}
Node temp = head.next;
int length = 0;
while (temp != null){
length++;
temp = temp.next;
}
return length;
}
4、找到倒数第k个节点（面试题）
思路：先统计出要查询的链表的长度 Size，for 循环以Size -k 为条件遍历到倒数第k个节点。
public Node k(int k) {
if (head.next == null) {
return null;
}
int size = length(head);
if (k <= 0 || size - k < 0) {
return null;
}
Node temp = head.next;
for (int i = 0; i < size - k; i++) {
temp = temp.next;
}
return temp;
}
4、将一个链表反转（1234——>4321）（面试题）
思路：
- 定义一个反转头节点，作为反转链表的临时头节点（reverseHead）
- 定义一个辅助节点（cur），帮助遍历原来链表，每遍历一个将其取下插入到reverseHead 的后面
- 最后将原来的头节点（head）指向（reverseHead.next）
难点：将其取下后要怎么操作？
public void reverse(Node head) {
if(head.next==null || head.next.next==null){
return; //无需反转
}
Node cur = head.next; //辅助遍历节点
Node next = null; //先定位cur的下一节点，以防摘下节点后丢失下一节点的位置
Node reverseHead = new Node(0,"");
while (cur != null){
next = cur.next;
cur.next = reverseHead.next; //1
reverseHead.next = cur; //2
cur = next;
}
head.next = reverseHead.next;
}
}
1和2两步是难点：
- 将2指向1
- 将reverseHead指向2
5、将单链表逆序打印出来（面试题）
思路：利用栈的特性实现。
public void reversePrint(Node head) {
if (head.next == null) {
System.out.println("链表为空");
return;
}
//创建要给一个栈，将各个节点压入栈
Stack<Node> nodeStack = new Stack<>();
Node cur = head.next;
while (cur != null) {
nodeStack.push(cur);
cur = cur.next;
}
while (nodeStack.size() > 0) {
System.out.println(nodeStack.pop());
}
}
6、leetcode-21 合并两个有序链表(MergeTwoSortedLists)
两种解法：循环和递归，且链表不使用头节点。
循环
递归调用
四、单向环形链表
1、问题引出：Josephu(约瑟夫、约瑟夫环)
设编号为 1，2，… n 的 n 个人围坐一圈，约定编号为 k（1<=k<=n）的人从 1 开始报数，数到 m 的那个人出列，它的下一位又从 1 开始报数，数到 m 的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
2、思路：
用一个不带头结点的循环链表来处理问题：先构成一个有 n 个结点的单循环链表，然后由 k 结点起从 1 开始计数，计到 m 时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从 1 开始计数，直到最后一个结点从链表中删除算法结束。
3、实现：
构建单向环形链表
class CircleLinkedList {
linkedNode first = new linkedNode(-1); //辅助定位第一个节点
int size = 0; //计算当前链表的节点数量，以便遍历。
public void add(int val) {
linkedNode node = new linkedNode(val);
linkedNode cur = first; //first不能动，cur定位最后一个节点
if (first.next == null) {
first.next = node;
node.next = node;
size++;
} else {
for (int i = 0; i < size; i++) {
cur = cur.next;
}
cur.next = node;
node.next = first.next;
size++;
}
}
小孩出圈思路分析：
代码实现：
public void josephu(int n, int k, int m) {
if (n < 1 || k > n || k < 1 || m < 1) {
return;
}
for (int i = 1; i <= n; i++) {
this.add(i); //根据参数构建环形链表
}
int temp = m; //因为m需要多次循环使用，定义一个遍历记录它的值
linkedNode helper = first;
while (size != 0) { //将helper移动到最后一个节点处
helper = helper.next;
size--;
}
first = first.next; //使first置于第一个节点
while (k != 1) { //移动k-1次（first和helper紧挨，同时移动）
first = first.next;
helper = helper.next;
k--;
}
for (int i = 1; i < n; i++) { //循环出圈过程
while (m != 1) {
first = first.next;
helper = helper.next;
m--;
}
System.out.println(first.num);
first = first.next;
helper.next = first;
m = temp;
}
System.out.println(first.num); //最后一个节点
}
五、栈（数组实现）
概述：
先入后出
允许插入和删除的一端，为变化的一端，称为栈顶(Top)
另一端为固定的一端，称为栈底(Bottom)
栈的应用场景：
- 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
- 处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
- 表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。
- 二叉树的遍历。
- 图形的深度优先(depth 一 first)搜索法。
代码实现：
class ArrayStack {
private int maxSize; // 栈的大小
private int[] stack; // 数组模拟栈，数据就放在该数组
private int top = -1;// top表示栈顶，初始化为-1
//构造器
public ArrayStack(int maxSize) {
this.maxSize = maxSize;
stack = new int[this.maxSize];
}
//栈满
public boolean isFull() {
return top == maxSize - 1;
}
//栈空
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()) {
//抛出异常，有返回值，不能直接return终止；
throw new RuntimeException("栈空，没有数据~");
}
int value = stack[top];
top--;
return value;
}
//返回当前栈顶的值
public int peek() {
return stack[top];
}
//[遍历栈]，遍历时，需要从栈顶开始显示数据
public void list() {
if(isEmpty()) {
System.out.println("栈空，没有数据~~");
return;
}
//需要从栈顶开始显示数据
for(int i = top; i >= 0 ; i--) {
System.out.printf("stack[%d]=%d\n", i, stack[i]);
}
}
}
栈实现四则运算
需要在ArrayStack类中增加通用的方法：
//返回运算符的优先级，数字越大，则优先级就越高.
public int priority(int oper) {
if(oper == '*' || oper == '/'){
return 1;
} else if (oper == '+' || oper == '-') {
return 0;
} else {
return -1; // 假定目前的表达式只有 +, - , * , /
}
}
//判断是不是一个运算符
public boolean isOper(char val) {
return val == '+' || val == '-' || val == '*' || val == '/';
}
//计算方法
public int cal(int num1, int num2, int oper) {
int res = 0; // res 用于存放计算的结果
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;
}
代码实现四则运算的过程：
public static void main(String[] args) {
String expression = "7*2*2-5+1-5+3-4";
//创建两个栈，数栈，一个符号栈
ArrayStack2 numStack = new ArrayStack2(10);
ArrayStack2 operStack = new ArrayStack2(10);
//定义需要的相关变量
int index = 0;//用于扫描
int num1 = 0, num2 = 0, oper = 0, res = 0;
char ch = ' '; //将每次扫描得到char保存到ch
String keepNum = ""; //用于拼接 多位数
//开始while循环的扫描expression
while(true) {
//依次得到expression 的每一个字符
ch = expression.charAt(index);
//判断ch是什么，然后做相应的处理
if(operStack.isOper(ch)) { //如果是运算符
//判断当前的符号栈是否为空
if(!operStack.isEmpty()) {
//如果符号栈有操作符，进行比较,如果当前的操作符的优先级小于或者等于栈顶的操作符,就需要从数栈中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 {
//如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈.
operStack.push(ch);
}
}else {
//如果为空直接入符号栈..
operStack.push(ch);
}
} else { //如果是数，则直接入数栈
//numStack.push(ch - 48); / "1+3" '1' => 1
//分析思路
//1. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
//2. 在处理数，需要向expression的表达式的index 后再看一位,
// 如果是数就进行扫描，如果是符号才入栈
//3. 因此我们需要定义一个变量 字符串，用于拼接
//处理多位数
keepNum += ch;
//如果ch已经是expression的最后一位，就直接入栈
if (index == expression.length() - 1) {
numStack.push(Integer.parseInt(keepNum));
}else{
//判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
//注意是看后一位，不是index++
if (operStack.isOper(expression.substring(index+1,index+2).charAt(0))) {
//如果后一位是运算符，则入栈 keepNum = "1" 或者 "123"
numStack.push(Integer.parseInt(keepNum));
//重要的!!!!!!, keepNum清空
keepNum = "";
}
}
}
//让index + 1, 并判断是否扫描到expression最后.
index++;
if (index >= expression.length()) {
break;
}
}
//当表达式扫描完毕，就顺序的从 数栈和符号栈中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);//入栈
}
//将数栈的最后数，pop出，就是结果
int res2 = numStack.pop();
System.out.printf("表达式 %s = %d", expression, res2);
}
问题：逻辑复杂，代码复杂，仅完成多位数的四则运算就就很繁琐
原因：中缀表达式便于人计算，但不利于计算机理解。
解决：将 中缀表达式 转成 后缀表达式 ，在进行计算。
逆波兰计算器
后缀表达式又称作逆波兰表达式。例如：
(3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 -
当计算机利用后缀表达式进行运算时就特别流畅。
中缀表达式——>后缀表达式（逆波兰表达式）
思路：
- 初始化两个栈：运算符栈 s1 和储存中间结果的栈 s2；
- 从左至右扫描中缀表达式；
- 遇到操作数时，将其压 s2；
- 遇到运算符时，比较其与 s1 栈顶运算符的优先级：
- 如果 s1 为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
- 否则，若优先级比栈顶运算符的高，也将运算符压入 s1；
- 否则，将 s1 栈顶的运算符弹出并压入到 s2 中，再次转到(4-1)与 s1 中新的栈顶运算符相比较；
- 遇到括号时： (1) 如果是左括号“(”，则直接压入 s1 (2) 如果是右括号“)”，则依次弹出 s1 栈顶的运算符，并压入 s2，直到遇到左括号为止，此时将这一对括号丢弃
- 重复步骤 2 至 5，直到表达式的最右边
- 将 s1 中剩余的运算符依次弹出并压入 s2
- 依次弹出 s2 中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
由上述步骤可知：
s2这个栈只进不出，而且她的出栈的逆序才是逆波兰表达式
所以可以直接用一个顺序存储的结构（ArrayList）代替栈s2
举例说明:
将中缀表达式“1+((2+3)×4)-5”转换为后缀表达式的过程如下 ：
因此结果为 :“1 2 3 + 4 × + 5 –”
代码实现：（中缀转后缀 核心代码）
//即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5] =》 ArrayList [1,2,3,+,4,*,+,5,–]
//方法：将得到的中缀表达式对应的List => 后缀表达式对应的List
public static List<String> parseSuffixExpressionList(List<String> ls) {
Stack<String> s1 = new Stack<String>(); // 符号栈
List<String> s2 = new ArrayList<String>(); // 储存中间结果的List s2
for(String item: ls) {
if(item.matches("\\d+")) {
s2.add(item);
} else if (item.equals("(")) {
s1.push(item);
} else if (item.equals(")")) {
//如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，
//直到遇到左括号为止，此时将这一对括号丢弃
while(!s1.peek().equals("(")) {
s2.add(s1.pop());
}
s1.pop(); //!!! 将 ( 弹出 s1栈， 消除小括号
} else {
//当item的优先级小于等于s1栈顶运算符, 将s1栈顶的运算符弹出并加入到s2中
//再次转到(4.1)与s1中新的栈顶运算符相比较
while(s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item) ) {
s2.add(s1.pop());
}
//还需要将item压入栈
s1.push(item);
}
}
//将s1中剩余的运算符依次弹出并加入s2
while(s1.size() != 0) {
s2.add(s1.pop());
}
return s2; //注意因为是存放到List, 因此按顺序输出就是对应的后缀表达式对应的List
}
代码实现：（逆波兰运算 核心代码）
public static int calculate(List<String> ls) {
// 创建给栈, 只需要一个栈即可
Stack<String> stack = new Stack<String>();
for (String item : ls) {
// 这里使用正则表达式来取出数
if (item.matches("\\d+")) {
// 匹配的是多位数
stack.push(item);
} else {
// pop出两个数，并运算， 再入栈
int num2 = Integer.parseInt(stack.pop());
int num1 = Integer.parseInt(stack.pop());
int res = 0;
if (item.equals("+")) {
res = num1 + num2;
} else if (item.equals("-")) {
res = num1 - num2;
} else if (item.equals("*")) {
res = num1 * num2;
} else if (item.equals("/")) {
res = num1 / num2;
} else {
throw new RuntimeException("运算符有误");
}
//把res 入栈
stack.push("" + res);
}
}
//最后留在stack中的数据是运算结果
return Integer.parseInt(stack.pop());
}
六、递归
递归就是方法自己调用自己,每次调用时传入不同的变量
递归需要遵守的重要规则
- 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
- 方法的局部变量是独立的，不会相互影响, 比如 n 变量
- 如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据.
- 递归必须向退出递归的条件逼近，否则就是无限递归,出现 StackOverflowError（栈溢出）
- 当一个方法执行完毕，或者遇到 return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕
迷宫问题
小球能否到达出口，到达的路径是什么？
思路分析：
- 小球应根据一个策略来前进（下右上左）
- 当四个方向都走不通时，回溯到上一个点
//使用递归回溯来给小球找路
//说明
//1. map 表示地图
//2. i,j 表示从地图的哪个位置开始出发 (1,1)
//3. 如果小球能到 map[6][5] 位置，则说明通路找到.
//4. 约定： 当map[i][j] 为 0 表示该点没有走过 当为 1 表示墙；2 表示通路可以走；3 表示该点已经走过，但是走不通
//5. 在走迷宫时，需要确定一个策略(方法) 下->右->上->左 , 如果该点走不通，再回溯
/**
* @return 如果找到通路，就返回true, 否则返回false
*/
public boolean setWay(int[][] map, int i, int j) {
if(map[6][5] == 2) { // 通路已经找到ok
return true;
} else {
if(map[i][j] == 0) { //如果当前这个点还没有走过
//按照策略 下->右->上->左 走
map[i][j] = 2; // 假定该点是可以走通.
if(setWay(map, i+1, j)) {//向下走
return true;
} else if (setWay(map, i, j+1)) { //向右走
return true;
} else if (setWay(map, i-1, j)) { //向上
return true;
} else if (setWay(map, i, j-1)){ // 向左走
return true;
} else {
//说明该点是走不通，是死路
map[i][j] = 3;
return false;
}
} else { // 如果map[i][j] != 0 , 可能是 1， 2， 3
return false;
}
}
}
小球得到的路径，和程序员设置的找路策略有关
回溯：当四个条件都为false 时，这个点置为3后返回 false 给上一个点，上一个点又继续判断剩下条件（即又往其他方向走）；以此类推层层往上就是回溯。
八皇后问题
八皇后问题，是回溯算法的典型案例。在 8×8 格的国际象棋上摆放八个皇后，使其不能互相攻击即：任意两个皇后都不能处于同一行、 同一列或同一斜线上，问有多少种摆法(92)。
思路分析：
- 第一个皇后先放第一行第一列
- 第二个皇后放在第二行第一列、然后判断是否 OK， 如果不 OK，继续放在第二列、第三列、依次把所有列都放完，找到一个合适
- 继续第三个皇后，还是第一列、第二列……直到第 8 个皇后也能放在一个不冲突的位置，算是找到了一个正确解
- 当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解， 全部得到.
- 然后回头继续第一个皇后放第二列，后面继续循环执行 1,2,3,4 的步骤
代码实现：
//前期准备：
//定义一个max表示共有多少个皇后
int max = 8;
//用一个一维数组array, 保存皇后放置位置,比如 arr = {0 , 4, 7, 5, 2, 6, 1, 3}
int[] array = new int[max];
// array[n] ：其中n表示第几个皇后/第几行，array[n] 表示第n个皇后放在第array[n] 列
//编写一个方法，放置第n个皇后
//特别注意： check 是 每一次递归时，进入到check中都有 for(int i = 0; i < max; i++)，因此会有回溯
public void check(int n) {
if (n == max) { //n从0开始，当n=8进入时，实际上是放第9个，证明前面八个没有冲突，得到一种正确解。
return;
}
for (int i = 0; i < max; i++) { //将每行的所有列都放一边
array[n] = i;
if (judge(n)) {
//不冲突，进入递归，摆下一个皇后
check(n + 1);
}
//如果冲突，就继续执行 array[n] = i; 列后移一位
}
}
//此方法用来判断第n个皇后放的位置与前n-1个皇后有没有冲突
public boolean judge(int n) {
for (int i = 0; i < n; i++) { //循环是为了将第n个依次与前n-1个比较
//1. array[i] == array[n] 表示是否在同一列
//2. Math.abs(n-i) == Math.abs(array[n] - array[i]) 表示是否在同一斜线(行与列相差的距离一致)
if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])) {
return false;
}
}
return true;
}
