第 3 章:稀疏数组和队列
1、稀疏数组
1.1、实际需求
- 编写的五子棋程序中,有存盘退出和续上盘的功能
- 因为该二维数组的很多值是默认值 0 ,因此记录了很多没有意义的数据,我们将其转为稀疏数组进行存储
1.2、稀疏数组应用
- 1.2.1、稀疏数组处理方法
- 稀疏数组把具有不同值的元素的行列及值记录在一个小规模的数组中,从而缩小程序的规模
稀疏数组也是二维数组,行数由原数组的数据决定,列数一般为 3 列 - 稀疏数组的第一行记录原数组一共有几行几列,有多少个不为零的值
- 第一列:原数组的行数
- 第二列:原数组的列数
- 第三列:原数组有多少个不为零的值
之后的行记录原数组中不为零(x)的值所在的行数、列数以及 x 的值 - 第一列:x 在原数组中的行数
- 第二列:x 在原数组中的列数
- 第三列:x 的值
1.2.2、举例说明
- 原始二维数组较大,压缩后占用空间减少
1.3、应用实例
- 1.3.1、思路分析
- 使用稀疏数组, 来保留类似前面的二维数组(棋盘、 地图等等)
- 把稀疏数组存盘, 并且可以从新恢复原来的二维数组数
-
1.3.2、代码实现
-
代码
package ArrayAndQueue;
import java.io.*;
import java.util.Arrays;
// 原始二维数组--》稀疏数组--》还原为原始数组
public class arr01 {
public static void main(String[] args) {
//1. 创建一个原始的二维数组 8*9
// 0: 表示没有棋子, 1 表示 黑子 2 表蓝子
int[][] oriArr = new int[6][9];
oriArr[1][2] = 1;
oriArr[1][5] = 1;
oriArr[4][2] = 2;
oriArr[5][3] = 2;
//打印原始数组
System.out.println("原始数组开始~~");
for (int i = 0; i < oriArr.length; i++) {
for (int j = 0; j < oriArr[0].length; j++) {
System.out.print(oriArr[i][j] + "\t");
}
System.out.println();
}
System.out.println("原始数组完毕~~");
//2. 创建稀疏数组
//遍历原始数组,记录非0数据个数
int cnt = 0;
for (int i = 0; i < oriArr.length; i++) {
for (int j = 0; j < oriArr[0].length; j++) {
if (oriArr[i][j] != 0)
cnt++;
}
}
int[][] spareArr = new int[cnt + 1][3];
int k = 0;
spareArr[k][0] = oriArr.length;
spareArr[k][1] = oriArr[0].length;
spareArr[k][2] = cnt;
k++;
//3. 为稀疏数组赋值
for (int i = 0; i < oriArr.length; i++) {
for (int j = 0; j < oriArr[0].length; j++) {
if (oriArr[i][j] != 0) {
spareArr[k][0] = i;
spareArr[k][1] = j;
spareArr[k][2] = oriArr[i][j];
k++;
}
}
}
//打印稀疏数组
System.out.println("稀疏数组开始~~");
for (int i = 0; i < spareArr.length; i++) {
for (int j = 0; j < spareArr[0].length; j++) {
System.out.print(spareArr[i][j] + "\t");
}
System.out.println();
}
System.out.println("稀疏数组结束~~");
//4.1将稀疏数组保存到磁盘
File file = null;
FileOutputStream fos = null;
OutputStreamWriter osw = null;
try {
System.out.println("创建文件,开始保存到磁盘:");
file = new File("map.data");
fos = new FileOutputStream(file);
osw = new OutputStreamWriter(fos);
System.out.println("写入中...");
for (int i = 0; i < spareArr.length; i++) {
osw.write(spareArr[i][0] + " " + spareArr[i][1] + " " + spareArr[i][2]+" ");
}
System.out.println("保存成功!");
osw.close();
fos.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
}
//4.2读取稀疏数组到内存
FileInputStream fis = null;
byte[] b;
StringBuffer sb;
String[] split = null;
//创建一个新的稀疏数组
int[][] spareArr2 = null;
try {
System.out.println("读取存盘...");
fis = new FileInputStream(file);
int i;
sb = new StringBuffer();
b = new byte[2]; //容器:装载读取到的字节流
while ((i = fis.read(b)) != -1) {
sb.append(new String(b, 0, i));
}
split = sb.toString().split(" ");
System.out.println(Arrays.toString(split));
//为新的稀疏数组赋值
spareArr2 = new int[split.length/3][3];
for (int j = 0; j < split.length; j++) {
spareArr2[j / 3][j % 3] = Integer.parseInt(split[j]);
}
System.out.println("读取完成!");
System.out.println("恢复的稀疏数组开始~~");
for (int m = 0; m < spareArr2.length; m++) {
for (int n = 0; n < spareArr2[0].length; n++) {
System.out.print(spareArr2[m][n] + "\t");
}
System.out.println();
}
System.out.println("恢复的稀疏数组结束~~");
} catch (Exception e) {
e.printStackTrace();
}
//5.恢复原数组
//创建恢复数组
int[][] revcArr = new int[spareArr[0][0]][spareArr[0][1]];
//为回复数组赋值
for (int i = 1; i < spareArr2.length; i++) {
revcArr[spareArr2[i][0]][spareArr2[i][1]] = spareArr2[i][2];
}
//打印恢复数组
System.out.println("恢复数组开始~~");
for (int i = 0; i < revcArr.length; i++) {
for (int j = 0; j < revcArr[0].length; j++) {
System.out.print(revcArr[i][j] + "\t");
}
System.out.println();
}
System.out.println("恢复数组结束~~");
}
}
- 结果
原始数组开始~~
0 0 0 0 0 0 0 0 0
0 0 1 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 2 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0
原始数组完毕~~
稀疏数组开始~~
6 9 4
1 2 1
1 5 1
4 2 2
5 3 2
稀疏数组结束~~
创建文件,开始保存到磁盘:
写入中...
保存成功!
读取存盘...
[6, 9, 4, 1, 2, 1, 1, 5, 1, 4, 2, 2, 5, 3, 2]
读取完成!
恢复的稀疏数组开始~~
6 9 4
1 2 1
1 5 1
4 2 2
5 3 2
恢复的稀疏数组结束~~
恢复数组开始~~
0 0 0 0 0 0 0 0 0
0 0 1 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 2 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0
恢复数组结束~~
1.4、课后练习
- 在前面的基础上, 将稀疏数组保存到磁盘上, 比如 map.data
- 恢复原来的数组时, 读取 map.data 进行恢复
- 代码见上述,主要运用读入读出流。
2、队列
2.1、队列使用场景
银行排队的案例:
2.2、队列介绍
- 队列是一个有序列表, 可以用数组或是链表来实现。
- 遵循先入先出的原则, 即: 先存入队列的数据, 要先取出,后存入的要后取出
- 示意图: (使用数组模拟队列示意图)
2.3、数组模拟队列
-
2.3.1、思路分析
- maxSize :队列容量(数组的长度)
- arr :模拟队列的数组
- front :指向队列头部元素的前一个元素,初始值为 -1
- rear :指向队列尾部元素,初始值为 -1
-
基本操作
队列判空:front == rear
队列判满:rear == (maxSize - 1) ,即 rear 是否已经指向了数组的最后一个位置
队列元素个数:rear - front
队列入队:队列不满才能入队,arr[++rear] = value
队列出队:队列不空才能出队,return arr[front++] -
2.3.2 代码实现
2.4、数组模型环形队列
- 2.4.1、提出问题
目前数组使用一次就不能用, 没有达到复用的效果,造成内存空间的浪费
将这个数组使用算法, 改进成一个环形的队列(取模: %) - 2.4.2、思路分析
对前面的队列进行优化,改造为环形队列(通过取模实现)
maxSize :队列容量(数组的长度)
arr :模拟队列的数组
front :指向队列头部元素,初始值为 0
rear :指向队列尾部元素的后一个元素,初始值为 0
-
基本操作
- 队列判空:front == rear
- 队列判满:
- 为何要在 rear 之后,front 之前空出一个元素的空间?因为如果不空出一个元素,队列判空条件为:front == rear ,队列判满的条件也是:front == rear ,有歧义!
- 队列容量:因为空出了一个元素,所以队列容量就变成了 (maxSize - 1)
- 当空出一个元素的空间,如何判满?当还剩一个元素时,队列就已经满了,所以判断条件为 (rear + 1) % maxSize == front
- 队列元数个数:
- 计算公式:(rear + maxSize - front) % maxSize ,这样来思考:
- 当 rear 比 front 大时,即 (rear -front) > 0 ,这时还没有形成环形结构,(rear -front) 即是队列元素个数
- 当 rear 比 front 小时,即 (rear -front) < 0 ,这时已经形成了环形结构,(rear -front) 表示数组还差多少个元素存满(负数),(rear + maxSize - front) 即是队列元素个数
- 综上:(rear + maxSize - front) % maxSize
- 队列入队:
- 首先,队列不满才能入队
- 由于 rear 指向队列尾部元素的后一个元素,所以直接设置即可: arr[rear] = value
- 接下来,rear 应该向后移动一个位置:rear = (rear + 1) % maxSize
- 取模是为了防止数组越界,让指针从新回到数组第一个元素
- 队列出队:
- 首先,队列不空才能出队
- 由于 front 直接指向队列头部元素,所以直接返回该元素即可:int value = arr[front ]
- 接下来,front 应该向后移动一个位置:front = (front + 1) % maxSize
取模是为了防止数组越界,让指针从新回到数组第一个元素
-
2.4.3、代码实现
- 环形队列的实现